text stringlengths 49 983k |
|---|
//----------------------------templates
#pragma GCC optimize ("Ofast")
#pragma GCC target ("tune=native")
#pragma GCC target ("avx")
//----------------------------
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
#define int ll
#define FOR(i,j,n) for (int i=(int)(j);i<(n);i++)
#define REP(i,n) for (int i=0;i<(int)(n);i++)
#define REPS(i,n) for (int i=1;i<=(int)(n);i++)
#define REPN(i,n) for (int i=(int)(n)-1;i>=0;i--)
#define REPNS(i,n) for (int i=(int)(n);i>0;i--)
#define I(n) scanf("%lld", &(n))
#define LL(n) scanf("%lld", &(n))
#define pb(n) push_back((n))
#define mp(i,j) make_pair((i),(j))
#define eb(i,j) emplace_back((i),(j))
#define y0 y3487465
#define y1 y8687969
#define j0 j1347829
#define j1 j234892
#define uniq(v) v.erase( unique(v.begin(), v.end()), v.end() )
#define all(x) (x).begin(),(x).end()
#define sz(x) ((int)(x).size())
typedef vector<int> vi;
typedef pair<int,int> pi;
typedef vector<pi> vpi;
typedef vector<vi> vvi;
typedef vector<vpi> vvpi;
typedef vector<vvi> vvvi;
const int mod = 1000000007;
//--------------------------------------------
struct SegmentTree {
public:
int n;
vi node;
SegmentTree(vi v) {
int sz = v.size();
n = 1; while(n < sz) n *= 2;
node.resize(2*n-1, 0);
REP(i,sz) node[i+n-1] = v[i];
REPN(i,n-2) node[i] = max(node[2*i+1], node[2*i+2]);
}
void update(int k, int x){
k += n-1;
node[k] = x;
while(k){
k = (k-1)/2;
node[k] = max(abs(node[2*k+1]),abs(node[2*k+2]));
}
}
int getmax(int a, int b, int k=0, int l=0, int r=-1){
if(r<0) r=n;
if(r<=a || b<=l) return 0;
if(a<=l && r<=b) return abs(node[k]);
return max( getmax(a,b,2*k+1,l,(l+r)/2),getmax(a,b,2*k+2,(l+r)/2,r) );
}
int get(int k){ return node[k+n-1]; }
};
int n,a[100010];
map<int,int> zaatu;
signed main(){
I(n);
vi s(n+1);
SegmentTree st(s);
int zr = 1;
REP(i,n) {
I(a[i]);
if(!zaatu[a[i]]) zaatu[a[i]] = zr++;
}
int r = n-1;
bool init = true;
REP(i,n){
int vl = st.get(zaatu[a[i]]);
st.update(zaatu[a[i]], vl + 1);
int vr = st.get(zaatu[a[r-i]]);
st.update(zaatu[a[r-i]], vr - 1);
int cand = st.getmax(0,n);
if(!cand){
if(!init) printf(" ");
init = false;
printf("%lld", i+1);
}
}
printf("\n");
}
|
#include<iostream>
#include<map>
#include<vector>
#include<queue>
using namespace std;
int main(){
int n;
cin >> n;
int a[n];
for(int i = 0; i < n; i++) cin >> a[i];
/*
vector<int> ans;
map<int,int> x, y;
int ng = 0;
for(int i = 0; i < n; i++){
int j = n-1-i;
if(x[a[i]]==y[a[i]]) ng++;
x[a[i]]++;
if(x[a[i]] == y[a[i]]) ng--;
if(x[a[j]]==y[a[j]]) ng++;
y[a[j]]++;
if(x[a[j]] == y[a[j]]) ng--;
if(ng == 0) ans.push_back(i+1);
}
for(int i = 0; i < ans.size(); i++) cout << ans[i] << " \n"[i+1==ans.size()];
*/
// editorial
vector<int> ans;
priority_queue<int> x, y;
for(int i = 0; i < n; i++){
int j = n-1-i;
x.push(a[i]);
y.push(a[j]);
while(x.size() && x.top()==y.top()) x.pop(), y.pop();
if(x.size() == 0) ans.push_back(i+1);
}
for(int i = 0; i < ans.size(); i++) cout << ans[i] << " \n"[i+1==ans.size()];
return 0;
}
|
#include <iostream>
#include <fstream>
#include <string>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <vector>
#include <algorithm>
#include <numeric>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <deque>
#include <functional>
#include <cctype>
#define BIT(a) (1 << (a))
using namespace std;
long long MOD = 1000000007;
long long mod_pow(long long x, long long n){
long long res = 1;
for(int i = 0;i < 60; i++){
if(n >> i & 1) res = res * x % MOD;
x = x * x % MOD;
}
return res;
}
int a[100005];
vector<int> ans;
int main(void){
map<int, int> m;
int N;
cin >> N;
for (int i = 0; i < N; i++){
cin >> a[i];
}
for (int i = 0; i < N; i++){
m[a[i]]++;
m[a[N-1-i]]--;
if (!m[a[i]]) m.erase(a[i]);
if (!m[a[N-1-i]]) m.erase(a[N-1-i]);
if (m.empty()) ans.push_back(i+1);
}
for (size_t i = 0; i < ans.size(); i++){
if (i) cout << " ";
cout << ans[i];
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i=0; i<(int)(n); i++)
#define all(v) v.begin(), v.end()
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
const ll MOD = 1000000007;
const ll INF = 10000000000000000;
vector<int> x4 = {0, 1, 0, -1}, x8 = {0, 1, 1, 1, 0, -1, -1, -1};
vector<int> y4 = {1, 0, -1, 0}, y8 = {1, 1, 0, -1, -1, -1, 0, 1};
template<class T> struct edge { int from, to; T cost;};
template<class T> inline bool chmin(T& a, T b){if (a>b){a = b; return true;}return false;}
template<class T> inline bool chmax(T& a, T b){if (a<b){a = b; return true;}return false;}
template<class T> inline T powerM(T a,T b){if (b==0) return 1;
T tmp = powerM(a,b/2); if (b%2==0) return tmp*tmp%MOD; else return tmp*tmp%MOD*a%MOD; }
template<class T> inline T power(T a,T b,T m){ if (b==0) return 1;
T tmp = power(a,b/2,m); if (b%2==0) return tmp*tmp%m; else return tmp*tmp%m*a%m; }
template<class T> inline T gcd(T a, T b){if (b==0) return a; return gcd(b, a%b);}
template<class T> inline T lcm(T a, T b){return a / gcd(a,b) * b;}
// ax+by=gcd(a,b)を解く
template<class T> inline T extgcd(T a,T b,T &x,T &y){if (b==0){x=1; y=0; return a;} T d=extgcd(b,a%b,y,x); y -= a/b*x; return d;}
int main() {
int n; cin >>n;
vector<int> a(n); rep(i, n) cin >>a.at(i);
map<int,int> left, right;
int res = 0;
vector<int> k(n, -1);
int lefts = 0, rights = 0;
rep(i, n){
int x = a[i], y = a[n-1-i];
if (x != y){
if (right[x] > 0){
right[x]--;
if (right[x] == 0) rights--;
}else{
left[x]++;
if (left[x] == 1) lefts++;
}
if (left[y] > 0){
left[y]--;
if (left[y] == 0) lefts--;
}else{
right[y]++;
if (right[y] == 1) rights++;
}
}
if (lefts == 0 && rights == 0){
k[res] = i+1; res++;
}
}
rep(i, res){
cout <<k[i];
if (i < res-1) cout <<" ";
}
cout <<endl;
}
|
#define __USE_MINGW_ANSI_STDIO 0
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define int ll
using VI = vector<int>;
using VVI = vector<VI>;
using PII = pair<int, int>;
#define FOR(i, a, n) for (ll i = (ll)a; i < (ll)n; ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(x) x.begin(), x.end()
#define PB push_back
const ll LLINF = (1LL<<60);
const int INF = (1LL<<30);
const int MOD = 1000000007;
template <typename T> T &chmin(T &a, const T &b) { return a = min(a, b); }
template <typename T> T &chmax(T &a, const T &b) { return a = max(a, b); }
template <typename T> bool IN(T a, T b, T x) { return a<=x&&x<b; }
template<typename T> T ceil(T a, T b) { return a/b + !!(a%b); }
template<class S,class T>
ostream &operator <<(ostream& out,const pair<S,T>& a){
out<<'('<<a.first<<','<<a.second<<')';
return out;
}
template<class T>
ostream &operator <<(ostream& out,const vector<T>& a){
out<<'[';
REP(i, a.size()) {out<<a[i];if(i!=a.size()-1)out<<',';}
out<<']';
return out;
}
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
int a[100010];
signed main(void)
{
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
REP(i, n) cin >> a[i];
VI ans, yui(100010, 0);
map<int, int> kyoko;
int ptr = -1;
REP(i, n) {
kyoko[a[i]]++;
yui[++ptr] = a[n-i-1];
while(ptr >= 0) {
if (kyoko[yui[ptr]]) {
kyoko[yui[ptr]]--;
ptr--;
} else {
break;
}
}
if(ptr == -1) ans.PB(i+1);
}
REP(i, ans.size()) {
cout << ans[i];
if(i != ans.size()-1) cout << " ";
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, num1[100005], num2[100005];
map<int,int> A, B;
signed main(){
cin>>n;
for(int i=0;i<n;i++){
cin>>num1[i];
num2[i] = num1[i];
}
reverse( num2, num2 + n );
vector<int> ans;
int cnt = 0;
for(int i=0;i<n;i++){
if( A[num1[i]] < B[num1[i]] ) cnt--;
else cnt++;
A[num1[i]]++;
if( B[num2[i]] < A[num2[i]] ) cnt--;
else cnt++;
B[num2[i]]++;
if( cnt == 0 ) ans.push_back( i + 1 );
}
for(int i=0;i<ans.size();i++){
if(i) cout<<" ";
cout<<ans[i];
}
cout<<endl;
return 0;
}
|
// need
#include <iostream>
#include <algorithm>
// data structure
#include <bitset>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
//#include <complex>
//#include <deque>
#include <valarray>
// stream
//#include <istream>
//#include <sstream>
//#include <ostream>
#include <fstream>
// etc
#include <cassert>
#include <cmath>
#include <functional>
#include <iomanip>
#include <chrono>
#include <random>
#include <numeric>
// input
#define INIT std::ios::sync_with_stdio(false);std::cin.tie(0);
#define VAR(type, ...)type __VA_ARGS__;MACRO_VAR_Scan(__VA_ARGS__);
template<typename T> void MACRO_VAR_Scan(T& t) { std::cin >> t; }
template<typename First, typename...Rest>void MACRO_VAR_Scan(First& first, Rest&...rest) { std::cin >> first; MACRO_VAR_Scan(rest...); }
#define VEC_ROW(type, n, ...)std::vector<type> __VA_ARGS__;MACRO_VEC_ROW_Init(n, __VA_ARGS__); for(int i=0; i<n; ++i){MACRO_VEC_ROW_Scan(i, __VA_ARGS__);}
template<typename T> void MACRO_VEC_ROW_Init(int n, T& t) { t.resize(n); }
template<typename First, typename...Rest>void MACRO_VEC_ROW_Init(int n, First& first, Rest&...rest) { first.resize(n); MACRO_VEC_ROW_Init(n, rest...); }
template<typename T> void MACRO_VEC_ROW_Scan(int p, T& t) { std::cin >> t[p]; }
template<typename First, typename...Rest>void MACRO_VEC_ROW_Scan(int p, First& first, Rest&...rest) { std::cin >> first[p]; MACRO_VEC_ROW_Scan(p, rest...); }
#define VEC(type, c, n) std::vector<type> c(n);for(auto& i:c)std::cin>>i;
#define MAT(type, c, m, n) std::vector<std::vector<type>> c(m, std::vector<type>(n));for(auto& r:c)for(auto& i:r)std::cin>>i;
// output
#define OUT(d) std::cout<<(d);
#define FOUT(n, d) std::cout<<std::fixed<<std::setprecision(n)<<(d);
#define SOUT(n, c, d) std::cout<<std::setw(n)<<std::setfill(c)<<(d);
#define SP std::cout<<" ";
#define TAB std::cout<<"\t";
#define BR std::cout<<"\n";
#define SPBR(i, n) std::cout<<(i + 1 == n ? '\n' : ' ');
#define ENDL std::cout<<std::endl;
#define FLUSH std::cout<<std::flush;
#define SHOW(d) {std::cerr << #d << "\t:" << (d) << "\n";}
#define SHOWVECTOR(v) {std::cerr << #v << "\t:";for(const auto& xxx : v){std::cerr << xxx << " ";}std::cerr << "\n";}
#define SHOWVECTOR2(v) {std::cerr << #v << "\t:\n";for(const auto& xxx : v){for(const auto& yyy : xxx){std::cerr << yyy << " ";}std::cerr << "\n";}}
#define SHOWQUEUE(a) {auto tmp(a);std::cerr << #a << "\t:";while(!tmp.empty()){std::cerr << tmp.front() << " ";tmp.pop();}std::cerr << "\n";}
// utility
#define ALL(a) (a).begin(),(a).end()
#define FOR(i, a, b) for(int i=(a);i<(b);++i)
#define RFOR(i, a, b) for(int i=(b)-1;i>=(a);--i)
#define REP(i, n) for(int i=0;i<int(n);++i)
#define RREP(i, n) for(int i=int(n)-1;i>=0;--i)
#define FORLL(i, a, b) for(ll i=ll(a);i<ll(b);++i)
#define RFORLL(i, a, b) for(ll i=ll(b)-1;i>=ll(a);--i)
#define REPLL(i, n) for(ll i=0;i<ll(n);++i)
#define RREPLL(i, n) for(ll i=ll(n)-1;i>=0;--i)
#define IN(a, x, b) (a<=x && x<b)
template<typename T> inline T CHMAX(T& a, const T b) { return a = (a < b) ? b : a; }
template<typename T> inline T CHMIN(T& a, const T b) { return a = (a > b) ? b : a; }
#define EXCEPTION(msg) throw std::string("Exception : " msg " [ in ") + __func__ + " : " + std::to_string(__LINE__) + " lines ]"
#define TRY(cond, msg) try {if (cond) EXCEPTION(msg);}catch (std::string s) {std::cerr << s << std::endl;}
void CHECKTIME(std::function<void()> f) { auto start = std::chrono::system_clock::now(); f(); auto end = std::chrono::system_clock::now(); auto res = std::chrono::duration_cast<std::chrono::nanoseconds>((end - start)).count(); std::cerr << "[Time:" << res << "ns (" << res / (1.0e9) << "s)]\n"; }
// test
template<class T> std::vector<std::vector<T>> VV(int n, int m, T init = T()) {
return std::vector<std::vector<T>>(n, std::vector<T>(m, init));
}
template<typename S, typename T>
std::ostream& operator<<(std::ostream& os, std::pair<S, T> p) {
os << "(" << p.first << ", " << p.second << ")"; return os;
}
// type/const
#define int ll
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using PAIR = std::pair<int, int>;
using PAIRLL = std::pair<ll, ll>;
constexpr int INFINT = 1 << 30; // 1.07x10^ 9
constexpr int INFINT_LIM = (1LL << 31) - 1; // 2.15x10^ 9
constexpr ll INFLL = 1LL << 60; // 1.15x10^18
constexpr ll INFLL_LIM = (1LL << 62) - 1 + (1LL << 62); // 9.22x10^18
constexpr double EPS = 1e-9;
constexpr int MOD = 1000000007;
constexpr double PI = 3.141592653589793238462643383279;
template<class T, size_t N> void FILL(T(&a)[N], const T& val) { for (auto& x : a) x = val; }
template<class ARY, size_t N, size_t M, class T> void FILL(ARY(&a)[N][M], const T& val) { for (auto& b : a) FILL(b, val); }
template<class T> void FILL(std::vector<T>& a, const T& val) { for (auto& x : a) x = val; }
template<class ARY, class T> void FILL(std::vector<std::vector<ARY>>& a, const T& val) { for (auto& b : a) FILL(b, val); }
// ------------>8------------------------------------->8------------
signed main() {
INIT;
VAR(int, n);
VEC(int, a, n);
std::map<int, int> l, r;
std::vector<int> ans;
REP(i, n) {
++l[a[i]]; ++r[a[n - i - 1]];
if (l == r) ans.emplace_back(i + 1);
}
REP(i, ans.size()) {
OUT(ans[i])SPBR(i, ans.size());
}
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <bitset>
#include <map>
#include <tuple>
#include <unordered_set>
#include <unordered_map>
#include <list>
#include <numeric>
#include <utility>
#include <iterator>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <climits>
#include <ctime>
#include <cassert>
#include <random>
#include <cstring>
#define rep(i,n) for(int i=0;i<int(n);i++)
#define all(x) (x).begin(),x.end()
#define pb push_back
using namespace std;
using ll = long long;
const ll mod = 1000000007;
int dx[4]={1,0,-1,0};
int dy[4]={0,1,0,-1};
int ddx[8]={-1,-1,0,1,1,1,0,-1};
int ddy[8]={0,1,1,1,0,-1,-1,-1};
bool debug=false;
/*---------------------------------------------------*/
int main(){
int N;
cin >> N;
vector<int> a(N);
for(int i = 0; i < N; i++){
cin >> a[i];
}
map<int, int> x, y;
vector<int> ans;
for(int i = 0; i < N; i++){
x[a[i]]++;
y[a[N - 1 - i]]++;
if(x == y) ans.push_back(i + 1);
}
for(int i = 0; i < ans.size(); i++){
if(i)cout << ' ';
cout << ans[i];
}
cout << endl;
return 0;
}
|
#include <algorithm>
#include <cstdio>
#include <iostream>
#include <map>
#include <cmath>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#include <stdlib.h>
#include <stdio.h>
#include <bitset>
#include <cstring>
#include <deque>
#include <iomanip>
#include <limits>
#include <fstream>
using namespace std;
#define FOR(I,A,B) for(int I = (A); I < (B); ++I)
#define CLR(mat) memset(mat, 0, sizeof(mat))
typedef long long ll;
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
int N;cin>>N;
int a[N];
FOR(i,0,N)cin>>a[i];
int b[N];
FOR(i,0,N)b[N-i-1]=a[i];
map<int, int> ma,mb;
int diff=0;
vector<int> ans;
FOR(i,0,N){
if(a[i]!=b[i]){
diff+=2;
ma[a[i]]++;
mb[b[i]]++;
if(mb[a[i]]>0){
mb[a[i]]--;
ma[a[i]]--;
diff-=2;
}
if(ma[b[i]]>0){
ma[b[i]]--;
mb[b[i]]--;
diff-=2;
}
}
if(diff==0)ans.push_back(i+1);
}
FOR(i,0,ans.size()){
if(i)cout<<" ";
cout<<ans[i];
}
cout<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
/*{{{*/ //template
#define rep(i,n) for(int i=0;i<(int)(n);i++)
constexpr int INF = numeric_limits<int>::max()/2;
constexpr long long LINF = numeric_limits<long long>::max()/3;
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define all(v) (v).begin(),(v).end()
#define sz(x) (int)(x).size()
#define debug(x) cerr<<#x<<":"<<x<<endl
#define debug2(x,y) cerr<<#x<<","<<#y":"<<x<<","<<y<<endl
//struct fin{ fin(){ cin.tie(0); ios::sync_with_stdio(false); } } fin_;
struct Double{ double d; explicit Double(double x) : d(x){} };
ostream& operator<<(ostream& os,const Double x){ os << fixed << setprecision(20) << x.d; return os; }
template<typename T> ostream& operator<<(ostream& os,const vector<T>& vec){ os << "["; for(const auto& v : vec){ os << v << ","; } os << "]"; return os; }
template<typename T,typename U> ostream& operator<<(ostream& os,const pair<T,U>& p){ os << "(" << p.first << ","<< p.second <<")"; return os; }
template<typename T> ostream& operator<<(ostream& os,const set<T>& st){ os<<"{"; for(T v:st) os<<v<<","; os <<"}"; return os; }
template<typename T,typename U> inline void chmax(T &x,U y){ if(y>x) x = y; }
template<typename T,typename U> inline void chmin(T &x,U y){ if(y<x) x = y; }
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
ll gcd(ll a,ll b){ if(b==0) return a; else return gcd(b,a%b); }
//constexpr double eps = 1e-14;
constexpr double eps = 1e-10;
constexpr ll mod = 1e9+7;
const int dx[]={1,0,-1,0} ,dy[] = {0,1,0,-1};
/*}}}*/
int main(){
int N;
cin >> N;
vector<ll> a(N);
rep(i,N) cin >> a[i];
vector<ll> b(N);
map<ll,ll> z;
for(int i=0;i<N;i++){
if(z.count(a[i])) continue;
z[a[i]] = i;
}
for(int i=0;i<N;i++) b[i] = z[a[i]];
set<int> tmp;
vector<int> ans;
//debug(b);
vector<ll> cnt(N+1,0);
for(int i=0;i<N;i++){
cnt[b[i]]++;
cnt[b[N-1-i]]--;
if(cnt[b[i]] != 0) tmp.insert(b[i]);
else tmp.erase(b[i]);
if(cnt[b[N-1-i]] != 0) tmp.insert(b[N-i-1]);
else tmp.erase(b[N-i-1]);
if(tmp.size() == 0){
ans.push_back(i+1);
}
}
for(int i=0;i<ans.size();i++){
cout << ans[i];
if(i==ans.size()-1) cout << endl;
else cout << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define rep(i,n) FOR(i,0,n)
#define pb emplace_back
typedef long long ll;
typedef pair<ll,ll> pint;
int a[100001];
vector<int> v;
map<int,int> t;
int main(){
int n;
cin>>n;
rep(i,n) cin>>a[i];
int cnt=0;
rep(i,n){
if(a[i]==a[n-i-1]&&cnt==0) v.pb(i+1);
else if(a[i]==a[n-i-1]&&cnt>=1) continue;
else if(a[i]!=a[n-i-1]){
++t[a[i]];--t[a[n-i-1]];
if(t[a[i]]==0) --cnt;
else if(t[a[i]]==1) ++cnt;
if(t[a[n-i-1]]==0) --cnt;
else if(t[a[n-i-1]]==-1) ++cnt;
if(cnt==0) v.pb(i+1);
}
}
rep(i,v.size()){
cout<<v[i]<<(i+1==v.size()?"":" ");
}
cout<<endl;
return 0;
}
|
#include <cstdio>
#include <algorithm>
#include <map>
#include <vector>
using namespace std;
const int SIZE = 100000;
int main(){
int n, a[SIZE];
scanf("%d",&n);
for(int i=0;i<n;i++){
scanf("%d",a+i);
}
map<int, int> b, e;
vector<int> ans;
int counter = 1000000000;
for(int i=0;i<n;i++){
if(b[a[i]] == e[a[i]]){
counter--;
}
if(b[a[n-i-1]] == e[a[n-i-1]]){
counter--;
}
b[a[i]]++;
e[a[n-i-1]]++;
if(b[a[i]] == e[a[i]]){
counter++;
}
if(b[a[n-i-1]] == e[a[n-i-1]]){
counter++;
}
if(counter == 1000000000){
ans.push_back(i+1);
}
}
for(int i=0;i<ans.size();i++){
printf("%d%c",ans[i], " \n"[i+1==ans.size()]);
}
return 0;
}
|
#include<iostream>
#include<string>
#include<cstdio>
#include<vector>
#include<cmath>
#include<algorithm>
#include<functional>
#include<iomanip>
#include<queue>
#include<ciso646>
#include<random>
#include<map>
#include<set>
#include<complex>
#include<bitset>
#include<stack>
#include<unordered_map>
#include<utility>
using namespace std;
typedef long long ll;
const ll mod = 1000000007;
#define rep(i,n) for(int i=0;i<n;i++)
#define Rep(i,sta,n) for(int i=sta;i<n;i++)
void solve() {
int n; cin >> n;
vector<int> a(n);
rep(i, n)cin >> a[i];
vector<int> ans;
map<int, int> mp;
rep(i, n) {
mp[a[i]]++;
if (mp[a[i]] == 0)mp.erase(a[i]);
mp[a[n - i - 1]]--;
if (mp[a[n - i - 1]] == 0)mp.erase(a[n - i - 1]);
if (mp.size() == 0)ans.push_back(i + 1);
}
int m = ans.size();
rep(i, m) {
cout << ans[i];
if (i != m - 1)cout << " ";
}
cout << endl;
return;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define INF_LL (int64)1e18
#define INF (int32)1e9
#define REP(i, n) for(int64 i = 0;i < (n);i++)
#define FOR(i, a, b) for(int64 i = (a);i < (b);i++)
#define all(x) x.begin(),x.end()
#define fs first
#define sc second
using int32 = int_fast32_t;
using uint32 = uint_fast32_t;
using int64 = int_fast64_t;
using uint64 = uint_fast64_t;
using PII = pair<int32, int32>;
using PLL = pair<int64, int64>;
const double eps = 1e-10;
template<typename A, typename B>inline void chmin(A &a, B b){if(a > b) a = b;}
template<typename A, typename B>inline void chmax(A &a, B b){if(a < b) a = b;}
int main(void){
cin.tie(0);
ios::sync_with_stdio(false);
int32 N;
cin >> N;
vector<int32> A(N);
REP(i, N) cin >> A[i];
map<int32, int32> fr, ba;
int32 out = 0;
vector<int32> res;
REP(i, N){
if(fr[A[i]] == ba[A[i]]) out++;
if(fr[A[N-i-1]] == ba[A[N-i-1]]) out++;
fr[A[i]]++;
ba[A[N-i-1]]++;
if(fr[A[i]] == ba[A[i]]) out--;
if(fr[A[N-i-1]] == ba[A[N-i-1]]) out--;
if(out == 0){
res.push_back(i+1);
}
}
sort(all(res));
REP(i, res.size()-1)
cout << res[i] << " ";
cout << res[res.size()-1] << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int,int>;
#define enld '\n'
#define rep(i,n) for(int i=0; i<(n); i++)
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("Ofast")
constexpr ll INF = 1e18;
constexpr int inf = 1e9;
constexpr ll mod = 1000000007;
constexpr ll mod2 = 998244353;
const double PI = 3.1415926535897932384626433832795028841971;
const int dx[6] = {1, 0, -1, 0,1,1};
const int dy[6] = {0, 1, 0, -1,1,-1};
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
// ---------------------------------------------------------------------------
int main(){
ios::sync_with_stdio(false);
cin.tie(nullptr);
int N;
cin >> N;
vector<int> A(N);
rep(i,N) cin >> A[i];
map<int,int> pre,suf;
vector<int> ans;
for(int i=0; i<N; i++){
pre[A[i]]++;
suf[A[N-1-i]]++;
if(pre == suf) ans.emplace_back(i);
}
for(int i=0; i<ans.size(); i++){
cout << ans[i]+1 << " \n"[i+1 == ans.size()];
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,f=0;
cin>>n;
int a[n];
priority_queue<int>q1,q2;
for(int i=0;i<n;i++)cin>>a[i];
for(int i=0;i<n;i++){
q1.push(a[i]);
q2.push(a[n-i-1]);
while(!q1.empty()&&q1.top()==q2.top())q1.pop(),q2.pop();
if(q1.empty()){
if(f++)cout<<' ';
cout<<i+1;
}
}cout<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n), b, ans;
for(int i=0;i<n;i++){
cin >> a[i];
}
b = a;
reverse(b.begin(), b.end());
map<int,int> cnta, cntb;
set<int> dif;
for(int i=0;i<n;i++){
if(a[i]!=b[i]){
cnta[a[i]]++;
cntb[b[i]]++;
if(cnta[a[i]]==cntb[a[i]]) dif.erase(a[i]);
else dif.insert(a[i]);
if(cnta[b[i]]==cntb[b[i]]) dif.erase(b[i]);
else dif.insert(b[i]);
}
if(dif.empty()){
ans.push_back(i+1);
}
}
for(int i=0;i<int(ans.size());i++){
cout << ans[i] << " \n"[i+1==ans.size()];
}
return 0;
}
|
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <climits>
#include <cfloat>
#include <cstring>
#include <map>
#include <utility>
#include <set>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <list>
#include <algorithm>
#include <functional>
#include <sstream>
#include <complex>
#include <stack>
#include <queue>
#include <unordered_set>
#include <unordered_map>
#include <array>
#include <cassert>
#include <bitset>
using namespace std;
using LL = long long;
int N;
int A[123456];
int B[123456];
map<int, int>P, Q;
int cnt;
int main(void)
{
cin >> N;
vector<int>vec;
for (int i = 0; i < N; ++i) {
cin >> A[i];
B[N - 1 - i] = A[i];
}
for (int i = 0; i < N; ++i) {
if (P[A[i]] != Q[A[i]]) {
cnt--;
}
if (A[i] != B[i] && P[B[i]] != Q[B[i]]) {
cnt--;
}
P[A[i]]++;
Q[B[i]]++;
if (P[A[i]] != Q[A[i]]) {
cnt++;
}
if (A[i] != B[i] && P[B[i]] != Q[B[i]]) {
cnt++;
}
if (cnt == 0) {
vec.push_back(i + 1);
}
}
for (int i = 0; i < vec.size(); ++i) {
cout << vec[i];
if (i + 1 != vec.size()) {
cout << " ";
}
}
cout << endl;
return 0;
}
|
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cstring>
#include <queue>
#include <vector>
#include <functional>
#include <map>
#include <set>
#include <cmath>
#include <string>
#define SIZE 100005
#define INF 1000000005LL
using namespace std;
typedef long long int ll;
typedef pair <int,int> P;
int n;
P A[SIZE];
int B[SIZE];
int C[SIZE];
int main()
{
scanf("%d",&n);
int a;
for(int i=0;i<n;i++){
scanf("%d",&a);
A[i] = make_pair(a,i);
}
sort(A,A+n);
int cnt=0;
for(int i=0;i<n;i++){
B[A[i].second] = cnt;
if(A[i].first < A[i+1].first)cnt++;
}
int c=0;
bool b=false;
for(int i=0;i<n;i++){
int f = B[i];
int s = B[n-1-i];
if(f!=s){
C[f]++;
C[s]--;
if(C[f] == 0)c--;
if(C[s] == 0)c--;
if(C[f] == 1)c++;
if(C[s] == -1)c++;
}
if(c==0){
if(!b)b=true;
else printf(" ");
printf("%d",i+1);
}
}
printf("\n");
return 0;
}
|
// 基本テンプレート
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <string>
#include <cstring>
#include <deque>
#include <list>
#include <queue>
#include <stack>
#include <vector>
#include <utility>
#include <algorithm>
#include <map>
#include <set>
#include <complex>
#include <cmath>
#include <limits>
#include <cfloat>
#include <climits>
#include <ctime>
#include <cassert>
#include <numeric>
#include <fstream>
#include <functional>
using namespace std;
#define rep(i,a,n) for(int (i)=(a); (i)<(n); (i)++)
#define repq(i,a,n) for(int (i)=(a); (i)<=(n); (i)++)
#define repr(i,a,n) for(int (i)=(a); (i)>=(n); (i)--)
#define debug(...) fprintf(stderr, __VA_ARGS__)
#define int long long int
template<typename T> void chmax(T &a, T b) {a = max(a, b);}
template<typename T> void chmin(T &a, T b) {a = min(a, b);}
template<typename T> void chadd(T &a, T b) {a = a + b;}
typedef pair<int, int> pii;
typedef long long ll;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
const ll INF = 1001001001001001LL;
const ll MOD = 1000000007LL;
signed main() {
int N; cin >> N;
vector<int> vec(N);
for(int i=0; i<N; i++) {
cin >> vec[i];
}
vector<int> ans;
priority_queue<int> pre, suf;
for(int i=0; i<N; i++) {
pre.push(vec[i]);
suf.push(vec[N-i-1]);
while(pre.size() && suf.size()) {
if(pre.top() != suf.top()) break;
pre.pop(); suf.pop();
}
if(pre.empty() && suf.empty()) ans.push_back(i+1);
}
for(size_t i=0; i<ans.size(); i++) {
printf("%lld%c", ans[i], (i+1==ans.size() ? '\n' : ' '));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,n) for(int (i)=0;(i)<(int)(n);++(i))
#define all(x) (x).begin(),(x).end()
#define pb push_back
#define fi first
#define se second
#define dbg(x) cout<<#x" = "<<((x))<<endl
template<class T,class U> ostream& operator<<(ostream& o, const pair<T,U> &p){o<<"("<<p.fi<<","<<p.se<<")";return o;}
template<class T> ostream& operator<<(ostream& o, const vector<T> &v){o<<"[";for(T t:v){o<<t<<",";}o<<"]";return o;}
int main(){
int n;
cin >>n;
vector<int> a(n);
rep(i,n) cin >>a[i];
map<int,int> f,b;
set<int> diff;
vector<int> ans;
rep(i,n){
++f[a[i]];
++b[a[n-1-i]];
for(int v:{a[i], a[n-1-i]}){
if(f[v] == b[v]) diff.erase(v);
else diff.insert(v);
}
if(diff.empty()) ans.pb(i+1);
}
int A = ans.size();
rep(i,A) cout << ans[i] << " \n"[i==A-1];
return 0;
}
|
// header {{{
#include <bits/stdc++.h>
using namespace std;
// {U}{INT,LONG,LLONG}_{MAX,MIN}
#define INF INT_MAX/3
#define LLINF LLONG_MAX/3
#define MOD (1000000007LL)
#define MODA(a, b) a=((a)+(b))%MOD
#define MODP(a, b) a=((a)*(b))%MOD
#define inc(i, l, r) for(int i=(l);i<(r);i++)
#define dec(i, l, r) for(int i=(r)-1;i>=(l);i--)
#define pb push_back
#define se second
#define fi first
#define mset(a, b) memset(a, b, sizeof(a))
using LL = long long;
using G = vector<vector<int>>;
int di[] = {0, -1, 0, 1};
int dj[] = {1, 0, -1, 0};
// }}}
int main() {
cin.tie(0);ios::sync_with_stdio(false);
int n;cin >> n;
vector<int> a(n);
for(int i=0;i<n;i++) cin >> a[i];
map<int, queue<int>> mp;
for(int i=0;i<n;i++){
mp[a[i]].push(i);
}
vector<bool> ok(n, false);
vector<int> ans;
int ptr = 0;
for(int i=n-1;i>=0;i--){
int p = mp[a[i]].front();
mp[a[i]].pop();
ok[p] = true;
if(ok[ptr]){
for(int j=ptr+1;j<n;j++){
if(ok[j] == false){
ptr = j;
break;
}
}
if(ok[ptr]){
ptr = n;
}
}
if(ptr == n-i){
ans.push_back(ptr);
}
}
// out
sort(ans.begin(), ans.end());
int m = ans.size();
for(int i=0;i<m;i++){
cout << ans[i];
if(i != m-1){
cout << " ";
}
}
cout << endl;
return 0;
}
|
#include <stdio.h>
#include <cmath>
#include <algorithm>
#include <cfloat>
#include <stack>
#include <queue>
#include <vector>
#include <string>
#include <iostream>
#include <set>
#include <map>
#include <time.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
int main(){
int N;
scanf("%d",&N);
int* table = new int[N+1];
for(int i = 1; i <= N; i++)scanf("%d",&table[i]);
priority_queue<int> LEFT,RIGHT;
queue<int> ANS;
for(int i = 1; i <= N; i++){
LEFT.push(table[i]);
RIGHT.push(table[N+1-i]);
while(LEFT.empty() == false && RIGHT.empty() == false && LEFT.top() == RIGHT.top()){
LEFT.pop();
RIGHT.pop();
}
if(LEFT.empty() == true && RIGHT.empty() == true){
ANS.push(i);
}
}
printf("%d",ANS.front());
ANS.pop();
while(!ANS.empty()){
printf(" %d",ANS.front());
ANS.pop();
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define FOR(I,A,B) for(ll I = (A); I < (B); ++I)
const ll INF=1e15+7;
const ll N = 100001;
ll n,a[N],k=0;
priority_queue <ll> ak,an;
int main(){
cin>>n;
FOR(i,0,n){
cin>>a[i];
}
FOR(i,0,n){
ak.push(a[i]);
an.push(a[n-1-i]);
while(ak.top()==an.top()){
an.pop();
ak.pop();
if(ak.empty())break;
}
if(ak.empty()&&an.empty()){
if(k==0){
cout<<i+1;
k++;
}
else cout<<" "<<i+1;
}
}
cout<<endl;
return 0;
}
|
#include<iostream>
#include<iomanip>
#include<math.h>
#include<vector>
#include<algorithm>
#include<set>
#include<map>
#include<queue>
#include<stack>
#include<string>
#include<bitset>
#include<random>
#include<time.h>
#define INF 1000000000ll
#define MOD 1000000007ll
#define EPS 1e-10
#define REP(i,m) for(long long i=0; i<(ll)m; i++)
#define FOR(i,n,m) for(long long i=n; i<(ll)m; i++)
#define DUMP(a) for(long long dump=0; dump<(ll)a.size(); dump++) { cout<<a[dump]; if(dump!=(ll)a.size()-1) cout<<" "; else cout<<endl; }
#define ALL(v) v.begin(),v.end()
#define pb push_back
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef long double ld;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n;
cin>>n;
vector<ll> a(n);
REP(i,n) cin>>a[i];
vector<ll> ans;
vector<ll> b(n);
REP(i,n) b[i]=a[i];
sort(ALL(b));
b.erase(unique(ALL(b)),b.end());
map<ll,ll> at;
ll c=0;
REP(i,b.size()) {
at[b[i]]=c;
c++;
}
vector<ll> cnt(n+1);
ll hoge=0;
REP(i,n) {
cnt[at[a[i]]]++;
if(cnt[at[a[i]]]==1) hoge++;
else if(cnt[at[a[i]]]==0) hoge--;
cnt[at[a[n-1-i]]]--;
if(cnt[at[a[n-1-i]]]==-1) hoge++;
else if(cnt[at[a[n-1-i]]]==0) hoge--;
if(hoge==0) ans.pb(i+1);
}
if((ll)ans.size()==0) cout<<endl;
else DUMP(ans);
}
|
#include <iostream>
#include <map>
#include <algorithm>
using namespace std;
int a[100010];
int b[100010];
map<int, int> m;
int main(){
int N;
cin >> N;
for(int i = 0; i < N; ++i){
cin >> a[i];
}
int ckaz = 0;
bool check = false;
for(int i = 0; i < N; ++i){
if(a[i] != a[N-i-1]){
if(m[a[i]] == -1) ckaz--;
if(m[a[N-i-1]] == 1) ckaz--;
if(m[a[i]] == 0) ckaz++;
if(m[a[N-i-1]] == 0) ckaz++;
m[a[i]]++;
m[a[N-i-1]]--;
}
if(ckaz == 0){
if(check){
cout << " ";
}
check = true;
cout << i+1;
}
}
cout << endl;
}
|
#include "bits/stdc++.h"
using namespace std;
#define mod 1000000007
using ll = long long;
int dd[] = { 0, 1, 0, -1, 0 }; //→↓←↑
void solve()
{
int N;
cin >> N;
vector<int> A(N);
for (int i = 0; i < N; i++)
{
cin >> A[i];
}
map<int, int> P;
map<int, int> Q;
bool flag = false;
for (int i = 0; i < N; i++)
{
P[A[i]]++;
Q[A[N - i - 1]]++;
if (P == Q)
{
if (flag)cout << " ";
cout << (i + 1);
flag = true;
}
}
cout << endl;
}
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
solve();
return 0;
}
|
#include <iostream>
#include <vector>
#include <queue>
using namespace std;
int main() {
int n, cnt = 0; cin >> n;
priority_queue<int> l, r;
vector<int> a(n);
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < n; ++i) {
l.push(a[i]); r.push(a[n - i - 1]);
while (!l.empty() && (l.top() == r.top()))
l.pop(), r.pop();
if(l.empty()){
if (cnt++) cout << " ";
cout << i + 1;
}
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#ifdef _DEBUG
#define _GLIBCXX_DEBUG
#include "dump.hpp"
#else
#define dump(...)
#endif
//#define int long long
// typedef __int128_t Int;
#define DBG 1
#define rep(i, a, b) for (int i = (a); i < (b); i++)
#define rrep(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define loop(n) rep(loop, (0), (n))
#define all(c) begin(c), end(c)
const int INF =
sizeof(int) == sizeof(long long) ? 0x3f3f3f3f3f3f3f3fLL : 0x3f3f3f3f;
const int MOD = (int)(1e9) + 7;
const double PI = acos(-1);
const double EPS = 1e-9;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(12);
int N;
cin >> N;
vector<int> v(N);
rep(i, 0, N) { cin >> v[i]; }
map<int, int> p, q;
vector<int> ans;
rep(i, 0, N) {
p[v[i]]++, q[v[N - 1 - i]]++;
if (p == q)
ans.push_back(i + 1);
}
rep(i, 0, ans.size()) cout << ans[i] << (i == ans.size() - 1 ? '\n' : ' ');
return 0;
}
|
#define ll long long
#define pb push_back
#include<bits/stdc++.h>
using namespace std;
const int N = 200000;
int arr[N];
vector<int> v1, v2;
int n, x;
void solve(){
cin >> n;
unordered_map<int,int> l, r;
vector<int> rs;
v1.clear();
for(int i = 0; i < n; i++) cin >> x, v1.pb(x);
for(int i = 1; i <= n; i++){
int val1 = v1[i - 1];
int val2 = v1[n - i];
l[val1]++;
l[val2]--;
if(l[val2] == 0) l.erase(val2);
if(l[val1] == 0) l.erase(val1);
if(l.size() == 0) rs.pb(i);
}
for(int i = 0; i < rs.size(); i++){
if(i) cout << " ";
cout << rs[i];
}
cout << endl;
}
int main(){
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (auto &i : a) cin >> i;
vector<int> zip = a;
sort(zip.begin(), zip.end());
zip.erase(unique(zip.begin(), zip.end()), zip.end());
for (int i = 0; i < n; ++i) {
a[i] = lower_bound(zip.begin(), zip.end(), a[i]) - zip.begin();
}
vector<int> ans;
map<int, int> m;
for (int k = 0; k < n; ++k) {
m[a[k]]++;
m[a[n - k - 1]]--;
if (!m[a[k]]) m.erase(a[k]);
if (!m[a[n - k - 1]]) m.erase(a[n - k - 1]);
if (m.size() == 0) ans.push_back(k + 1);
}
for (int i = 0; i < ans.size(); ++i) {
cout << ans[i] << (i + 1 == ans.size() ? "\n" : " ");
}
}
|
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int INF = 1e9;
const ll LINF = 1e18;
template<class S,class T> ostream& operator << (ostream& out,const pair<S,T>& o){ out << "(" << o.first << "," << o.second << ")"; return out; }
template<class T> ostream& operator << (ostream& out,const vector<T> V){ for(int i = 0; i < V.size(); i++){ out << V[i]; if(i!=V.size()-1) out << " ";} return out; }
template<class T> ostream& operator << (ostream& out,const vector<vector<T> > Mat){ for(int i = 0; i < Mat.size(); i++) { if(i != 0) out << endl; out << Mat[i];} return out; }
template<class S,class T> ostream& operator << (ostream& out,const map<S,T> mp){ out << "{ "; for(auto it = mp.begin(); it != mp.end(); it++){ out << it->first << ":" << it->second; if(mp.size()-1 != distance(mp.begin(),it)) out << ", "; } out << " }"; return out; }
/*
<url:https://onlinejudge.u-aizu.ac.jp/services/room.html#RitsCamp18Day1/problems/C>
問題文============================================================
長さ N の数列 ai が与えられる。 次の条件を満たす整数 K(1≤K≤N) を全て出力せよ。
条件: a1,⋯,aK をうまく並び替えると aN−K+1,⋯,aN と一致する。
=================================================================
解説=============================================================
================================================================
*/
void solve(){
ll N; cin >> N;
vector<ll> a(N); for(auto& in:a) cin >> in;
map<ll,ll> mp1,mp2;
vector<ll> ans;
for(int i = 1; i <= N;i++){
mp1[a[i-1]]++;
mp2[a[N-i]]++;
[&]{
for(auto it:mp1){
if(it.second == mp2[it.first]) continue;
return;
}
ans.push_back(i);
}();
}
cout << ans << endl;
}
int main(void) {
cin.tie(0); ios::sync_with_stdio(false);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int N;
int A[100000];
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
#ifdef LOCAL
std::ifstream in("in");
std::cin.rdbuf(in.rdbuf());
#endif
cin >> N;
for(int i = 0; i < N; i++){
cin >> A[i];
}
map<int, int> m1, m2;
set<int> same;
vector<int> ans;
for(int i = 0; i < N; i++){
set<int> s;
m1[A[i]]++;
m2[A[N - 1 - i]]++;
s.insert(A[i]);
s.insert(A[N - 1 - i]);
for(auto a : s){
if(same.count(a)) same.erase(a);
}
for(auto a : s){
if(m1.count(a) && m2.count(a) && m1[a] == m2[a]){
same.insert(a);
}
}
if(same.size() == m1.size()){
ans.push_back(i + 1);
}
}
for(int i = 0; i < ans.size(); i++){
cout << ans[i];
if(i != ans.size() - 1) cout << " ";
}
cout << endl;
}
|
#include<bits/stdc++.h>
#define vi vector<int>
#define vvi vector<vector<int> >
using ll = long long;
using ld =long double;
#define int ll
#define INF 1e9
#define EPS 0.0000000001
#define rep(i,n) for(int i=0;i<n;i++)
#define loop(i,s,n) for(int i=s;i<n;i++)
#define all(in) in.begin(), in.end()
template<class T, class S> void cmin(T &a, const S &b) { if (a > b)a = b; }
template<class T, class S> void cmax(T &a, const S &b) { if (a < b)a = b; }
#define MAX 9999999
int dx[]={0,0,1,-1};
int dy[]={1,-1,0,0};
int W,H;
bool inrange(int x,int y){return (0<=x&&x<W)&&(0<=y&&y<H);}
using namespace std;
typedef pair<int, int> pii;
typedef pair<int,pii> piii;
#define MP make_pair
signed main(){
int n; cin >> n;
vector<int>v(n);
rep(i,n) cin >> v[i];
vector<int>ans;
map<int,int>s;
map<int, int>t;
string a,b;
rep(i,n){
s[v[i]]++;
t[v[n-i-1]]++;
if(s == t)ans.push_back(i);
}
if(ans.size()){
rep(i,ans.size()){
if(i){
cout << " ";
}
cout << ans[i]+1;
}
}else{
cout << 0;
}
cout<<endl;
}
|
#ifndef VS
#include<bits/stdc++.h>
#endif
using namespace std;
typedef long long LL;
#ifdef BTK
#define DEBUG if(1)
#else
#define CIN_ONLY if(1)
struct cww {cww() {CIN_ONLY{ios::sync_with_stdio(false); cin.tie(0);}}
}star;
#define DEBUG if(0)
#endif
#define ALL(v) (v).begin(),(v).end()
#define REC(ret, ...) std::function<ret (__VA_ARGS__)>
template <typename T>inline bool chmin(T &l, T r){bool a = l>r; if (a)l = r; return a;}
template <typename T>inline bool chmax(T &l, T r){bool a = l<r; if (a)l = r; return a;}
template <typename T>istream& operator>>(istream &is, vector<T> &v){for (auto &it : v)is >> it;return is;}
class range {private: struct I { int x; int operator*() { return x; }bool operator!=(I& lhs) { return x<lhs.x; }void operator++() { ++x; } }; I i, n;public:range(int n) :i({ 0 }), n({ n }) {}range(int i, int n) :i({ i }), n({ n }) {}I& begin() { return i; }I& end() { return n; }};
int main() {
int N;
cin >> N;
vector<int> A(N);
cin >> A;
auto B = A;
reverse(ALL(B));
map<int, int> cnt;
int diff = 0;
vector<int> ret;
for (int i : range(N)) {
if (cnt[A[i]] == 0)diff++;
cnt[A[i]]++;
if (cnt[A[i]] == 0)diff--;
if (cnt[B[i]] == 0)diff++;
cnt[B[i]]--;
if (cnt[B[i]] == 0)diff--;
if (diff == 0)ret.push_back(i + 1);
}
int K = ret.size();
for (int i : range(K)) {
cout << " " + (!i) << ret[i];
}
cout << endl;
return 0;
}
|
#define _USE_MATH_DEFINES
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <cmath>
#include <algorithm>
#include <vector>
#include <queue>
#include <map>
using namespace std;
//typedef pair<long long int, long long int> P;
long long int INF = 1e18;
long long int MOD = 1e9 + 7;
int a[110000];
int main(){
int N;
cin >> N;
for(int i = 0; i < N; i++){
cin >> a[i];
}
map<long long int, long long int> m;
int cnt = 0;
vector<int> v;
for(int i = 0; i < N; i++){
m[a[i]]++;
if(m[a[i]] == 0){
cnt++;
}else if(m[a[i]] == 1){
cnt--;
}
m[a[N - i - 1]]--;
if(m[a[N - i - 1]] == 0){
cnt++;
}else if(m[a[N - i - 1]] == -1){
cnt--;
}
if(cnt == 0){
v.push_back(i + 1);
}
}
for(int i = 0; i < v.size() - 1; i++){
cout << v[i] << " ";
}
cout << v[v.size() - 1] << endl;
return 0;
}
|
#include <iostream>
#include <map>
#include <vector>
using namespace std;
int main(){
int n,a[100000],b[100000];
cin>>n;
for(int i=0;i<n;i++){
cin>>a[i];
b[n-1-i]=a[i];
}
map <int,int> x,y;
vector <int> re;
for(int i=0;i<n;i++){
x[a[i]]++;
y[b[i]]++;
if(x==y) re.push_back(i+1);
}
for(int i=0;i<(int)re.size();i++){
if(i) cout<<" ";
cout<<re[i];
}
cout<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define stoi stoll
using ll=long long;
using vi=vector<int>;
using pii=pair<int,int>;
#define ALL(c) begin(c),end(c)
#define RALL(c) rbegin(c),rend(c)
#define ITR(i,b,e) for(auto i=(b);i!=(e);++i)
#define FORE(x,c) for(auto &x:c)
#define REPF(i,a,n) for(int i=a,i##len=(int)(n);i<i##len;++i)
#define REP(i,n) REPF(i,0,n)
#define REPR(i,n) for(int i=(int)(n);i>=0;--i)
#define SZ(c) ((int)c.size())
#define CONTAIN(c,x) (c.find(x)!=end(c))
#define OUTOFRANGE(y,x,h,w) ((y)<0||(x)<0||(y)>=(h)||(x)>=(w))
#define dump(...)
const signed INF_=1001001001; const long long INF=1001001001001001001LL;
const int DX[9]={0,1,0,-1,1,1,-1,-1,0},DY[9]={-1,0,1,0,-1,1,1,-1,0};
template<class T> ostream& operator<<(ostream &os,const vector<T> &v) {
ITR(i,begin(v),end(v))os<<*i<<(i==end(v)-1?"":" ");return os;}
template<class T> istream& operator>>(istream &is,vector<T> &v) {
ITR(i,begin(v),end(v)) is>>*i;return is;}
template<class T,class U> istream& operator>>(istream &is, pair<T,U> &p) {
is>>p.first>>p.second;return is;}
template<class T> bool chmax(T &a,const T &b){if(a<b){a=b;return 1;}return 0;}
template<class T> bool chmin(T &a,const T &b){if(a>b){a=b;return 1;}return 0;}
template<class T> using heap=priority_queue<T,vector<T>,greater<T>>;
struct{template<class T> operator T(){T x;cin>>x;return x;}} IN;
struct before_main_function {
before_main_function() {
cin.tie(0);ios::sync_with_stdio(false);
cout<<setprecision(15)<<fixed;
#define endl "\n"
}
} before_main_function;
//------------------8<------------------------------------8<--------------------
signed main() {
int n;
cin>>n;
vector<int> a(n);
cin>>a;
map<int,int> f,b;
vector<int> ans;
REP(i,n) {
f[a[i]]++;
b[a[n-1-i]]++;
if(f==b) {
ans.push_back(i+1);
}
}
cout<<ans<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const double EPS = (1e-7);
const ll INF =(1e9);
const double PI = (acos(-1));
const ll MOD = ll(1e9) + 7;
#define REP(i, n) for(ll i = 0; i < (ll)(n); i++)
#define REPR(i, n) for(ll i = n; i > -1; i--)
#define FOR(i, a, b) for (ll i = (ll)(a); i < (ll)(b); i++)
#define ALL(x) (x).begin(),(x).end()
#define SORT(x) sort((x).begin(), (x).end())
#define REVERSE(x) reverse((x).begin(), (x).end())
#define SZ(x) ((ll)(x).size())
#define pb push_back
#define mp make_pair
//chmax(a, b): a>bならaをbで更新 更新したときにtrueを返す
//chmin(a, b): a<bならaをbで更新 更新したときにtrueを返す
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
#define dump(x) cerr<< #x << "= " << (x) << endl;
int gcd(int a,int b){return b?gcd(b,a%b):a;};
int dx[4]={1,0,-1,0};
int dy[4]={0,1,0,-1};
int main(){
//input
ll n; cin >> n;
vector<ll> a(n);
REP(i, n){
cin >> a[i];
}
map<ll, ll> p;
map<ll, ll> q;
ll diff = 0;
REP(i, n){
if (a[i] != a[n - 1 - i]){
diff += 2 * (p[a[i]] - q[a[i]]) - 2 * (p[a[n - 1 - i]] - q[a[n - 1 - i]]) + 2;
}
if (diff == 0){
cout << i + 1;
if (i != n - 1){
cout << ' ';
}
}
p[a[i]] += 1;
q[a[n - 1 - i]] += 1;
}
cout << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
// macro
#define rep(i,n) for(i=0;i<n;i++)
#define ll long long
#define all(v) v.begin(), v.end()
// code starts
int main()
{
int n;cin>>n;
vector<int> a(n);
int i;
rep(i,n)cin>>a[i];
priority_queue<int> pq1;
priority_queue<int> pq2;
vector<int> ans(0);
rep(i,n)
{
pq1.push(a[i]);
pq2.push(a[n-1-i]);
//cout<<pq1.top()<<' '<<pq2.top()<<endl;
while(pq1.size()>0&&pq1.top()==pq2.top())
{
pq1.pop();
pq2.pop();
}
if(pq1.size()==0)
{
ans.emplace_back(i+1);
}
}
rep(i,ans.size())
{
if(i!=0)cout<<' ';
cout<<ans[i];
}
cout<<endl;
}
|
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
void compress(vector<int> &a) {
vector<int> sa; int i;
for (i = 0; i < a.size(); i++) sa.push_back(a[i]);
sort(sa.begin(), sa.end());
sa.erase(unique(sa.begin(), sa.end()), sa.end());
for (i = 0; i < a.size(); i++) a[i] = lower_bound(sa.begin(), sa.end(), a[i]) - sa.begin();
}
int n;
vector<int> a;
int cnt[100000];
int main() {
int i;
cin >> n;
a.resize(n);
for (i = 0; i < n; i++) cin >> a[i];
compress(a);
int nozeroCnt = 0;
vector<int> ans;
for (i = 0; i < n; i++) {
if (cnt[a[i]] == -1) nozeroCnt--; if (cnt[a[i]] == 0) nozeroCnt++;
cnt[a[i]]++;
if (cnt[a[n - 1 - i]] == 1) nozeroCnt--; if (cnt[a[n - 1 - i]] == 0) nozeroCnt++;
cnt[a[n - 1 - i]]--;
if (nozeroCnt == 0) {
ans.push_back(i + 1);
}
}
for (i = 0; i < ans.size(); i++) {
cout << ans[i];
if (i + 1 < ans.size()) cout << " ";
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
signed main(){
int N;cin >> N;
vector<int> vec;
for(int i = 0;i < N;i++){
int b;cin >> b;
vec.push_back(b);
}
map<int, int> mp1;
set<int> s;
map<int, int> mp2;
vector<int> ans;
for(int i = 0;i < N;i++){
int j = N - i - 1;
mp1[vec.at(i)]++;
mp2[vec.at(j)]++;
if(mp1[vec.at(i)] != mp2[vec.at(i)]){
s.insert(vec.at(i));
}else{
s.erase(vec.at(i));
}
if(mp1[vec.at(j)] != mp2[vec.at(j)]){
s.insert(vec.at(j));
}else{
s.erase(vec.at(j));
}
//cout<<s.size()<<endl;
if(s.empty()){
ans.push_back(i+1);
}
}
for(int i = 0;i < ans.size();i++){
cout<<ans.at(i)<<(i == ans.size() -1 ? "" : " ");
}
cout<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
#define fi first
#define se second
#define repl(i,a,b) for(ll i=(ll)(a);i<(ll)(b);i++)
#define rep(i,n) repl(i,0,n)
#define all(x) (x).begin(),(x).end()
#define dbg(x) cout<<#x"="<<x<<endl
#define mmax(x,y) (x>y?x:y)
#define mmin(x,y) (x<y?x:y)
#define maxch(x,y) x=mmax(x,y)
#define minch(x,y) x=mmin(x,y)
#define uni(x) x.erase(unique(all(x)),x.end())
#define exist(x,y) (find(all(x),y)!=x.end())
#define bcnt __builtin_popcount
#define INF 1e16
#define mod 1000000007
ll n;
ll a[101010];
map<ll,ll> pre,suf;
ll d=0;
vector<ll> res;
int main(){
cin>>n;
rep(i,n)cin>>a[i];
rep(i,(n/2)){
d-=abs(pre[a[i]]-suf[a[i]]);
pre[a[i]]++;
d+=abs(pre[a[i]]-suf[a[i]]);
d-=abs(pre[a[n-1-i]]-suf[a[n-1-i]]);
suf[a[n-1-i]]++;
d+=abs(pre[a[n-1-i]]-suf[a[n-1-i]]);
if(d==0){
res.push_back(i+1);
if(i+1!=n-1-i)res.push_back(n-1-i);
}
}
res.push_back(n);
sort(all(res));
uni(res);
cout<<res[0];
repl(i,1,res.size())cout<<" "<<res[i];
cout<<endl;
return 0;
}
|
#include<algorithm>
#include<iostream>
#include<vector>
#include<map>
using namespace std;
typedef long long lint;
typedef vector<int>vi;
typedef pair<int,int>pii;
#define rep(i,n)for(int i=0;i<(int)(n);++i)
map<int,int> fr;
int kr;
void add(int x,int p){
int old=fr[x];
fr[x]=old+p;
kr+=abs(fr[x])-abs(old);
}
int main(){
int n;
cin>>n;
vi a(n);
rep(i,n)cin>>a[i];
vi ans;
rep(i,n){
add(a[i],1);
add(a[n-1-i],-1);
if(kr==0)ans.push_back(i+1);
}
rep(i,ans.size()){
cout<<ans[i]<<(i==(int)ans.size()-1?"\n":" ");
}
}
|
#define _USE_MATH_DEFINES
#include <bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<ll, ll> LP;
const int MOD = 40;
const int INF = 1e9;
const ll LINF = 1e18;
const int dx[] = {0, 0, 1, -1};
const int dy[] = {1, -1, 0, 0};
const int ddx[] = {1, 1, 0, -1, -1, -1, 0, 1};
const int ddy[] = {0, 1, 1, 1, 0, -1, -1, -1};
ll gcd(ll a, ll b) {
if(b == 0) return a;
return gcd(b, a % b);
}
int extgcd(int a, int b, int& x, int&y) {
int d = a;
if(b != 0) {
d = extgcd(b, a % b, y, x);
y -= (a / b) * x;
}else {
x = 1;
y = 0;
}
return d;
}
int inv(int a) {
int x, y;
extgcd(a, MOD, x, y);
return (x + MOD) % MOD;
}
struct modint {
int val;
modint() {
val = 0;
}
modint(int n) {
val = n % MOD;
}
modint &operator=(const modint &x) {
val = x.val;
return *this;
}
bool operator==(const modint &rhs) const {return val == rhs.val;}
modint operator+(const modint &rhs) const {return modint((val + rhs.val + MOD) % MOD);}
modint operator-(const modint &rhs) const {return modint((val + MOD - rhs.val) % MOD);}
modint operator*(const modint &rhs) const {return modint((int)((ll)val * rhs.val % MOD));}
modint operator/(const modint &rhs) const {return modint((int)((ll)val * inv(rhs.val) % MOD));}
modint &operator+=(const modint &rhs) {
val = (val + rhs.val + MOD) % MOD;
return *this;
}
modint &operator-=(const modint &rhs) {
val = (val + MOD- rhs.val) % MOD;
return *this;
}
modint &operator*=(const modint &rhs) {
val = (int)((ll)val * rhs.val % MOD);
return *this;
}
modint &operator/=(const modint &rhs) {
val = (int)((ll)val * inv(rhs.val) % MOD);
return *this;
}
};
struct unitree {
int *par, *rank, *sz;
unitree(int n) {
par = new int[n];
rank = new int[n];
sz = new int[n];
for(int i = 0; i < n; i++) {
par[i] = i;
rank[i] = 0;
sz[i] = 1;
}
}
int root(int x) {
if(par[x] == x) return x;
else return par[x] = root(par[x]);
}
void merge(int x, int y) {
x = root(x);
y = root(y);
if(x == y) return;
if(rank[x] < rank[y]) {
par[x] = y;
sz[y] += sz[x];
}else {
par[y] = x;
if(rank[x] == rank[y]) rank[x]++;
sz[x] += sz[y];
}
}
bool same(int x, int y) {
return root(x) == root(y);
}
int siz(int x) {
return sz[root(x)];
}
};
int n;
ll k, *a, *f;
bool check(ll mid) {
ll tmp = 0;
rep(i, n) {
if(a[i] * f[i] <= mid) continue;
tmp += a[i] - mid / f[i];
}
return tmp > k;
}
ll bin(ll left, ll right) {
while(right - left > 1) {
ll mid = (left + right) / 2;
if(check(mid)) left = mid;
else right = mid;
}
return left;
}
struct vect {
ll x, y;
vect() {
x = 0;
y = 0;
}
vect(ll x, ll y) {
this->x = x;
this->y = y;
}
int posi() const {
if(x == 0 && y == 0) exit(1);
if(x > 0 && y == 0) return 0;
if(x > 0 && y > 0) return 1;
if(x == 0 && y > 0) return 2;
if(x < 0 && y > 0) return 3;
if(x < 0 && y == 0) return 4;
if(x < 0 && y < 0) return 5;
if(x == 0 && y < 0) return 6;
if(x > 0 && y < 0) return 7;
}
int posi(const vect& v) const {
ll s = x * v.y - y * v.x;
ll c = x * v.x + y * v.y;
if(s == 0 && c == 0) exit(1);
if(s == 0 && c > 0) return 0;
if(s > 0 && c > 0) return 1;
if(s > 0 && c == 0) return 2;
if(s > 0 && c < 0) return 3;
if(s == 0 && c < 0) return 4;
if(s < 0 && c < 0) return 5;
if(s < 0 && c == 0) return 6;
if(s < 0 && c > 0) return 7;
}
bool operator<(const vect& rhs) {
int p1 = posi();
int p2 = rhs.posi();
if(p1 != p2) return p1 < p2;
return rhs.x * y < x * rhs.y;
}
};
signed main() {
int n;
cin >> n;
int* a = new int[n];
rep(i, n) cin >> a[i];
multiset<int> f, b;
vector<int> ans;
for(int i = 0; i < n; i++) {
auto itr = b.find(a[i]);
if(itr == b.end()) f.insert(a[i]);
else b.erase(itr);
itr = f.find(a[n - 1 - i]);
if(itr == f.end()) b.insert(a[n - 1 - i]);
else f.erase(itr);
if(f.empty() && b.empty()) ans.push_back(i + 1);
}
rep(i, ans.size()) printf("%d%c", ans[i], i == ans.size() - 1? '\n' : ' ');
}
|
#include <iostream>
#include <vector>
#include <map>
using namespace std;
int main(){
int N;
cin >> N;
vector<int> A(N);
for(int i = 0; i < N; ++i) cin >> A[i];
int d = 0;
map<int,int> D;
vector<int> K;
for(int k = 0; k < N; ++k){
d -= abs(D[A[k]]);
++D[A[k]];
d += abs(D[A[k]]);
d -= abs(D[A[N-1-k]]);
--D[A[N-1-k]];
d += abs(D[A[N-1-k]]);
if(!d) K.push_back(k+1);
// cerr << k << " " << d << endl;
}
for(size_t i = 0; i < K.size(); ++i)
cout << K[i] << (i+1 < K.size() ? " " : "\n");
}
|
#include <bits/stdc++.h>
#define _overload(_1,_2,_3,name,...) name
#define _rep(i,n) _range(i,0,n)
#define _range(i,a,b) for(int i=int(a);i<int(b);++i)
#define rep(...) _overload(__VA_ARGS__,_range,_rep,)(__VA_ARGS__)
#define _rrep(i,n) _rrange(i,n,0)
#define _rrange(i,a,b) for(int i=int(a)-1;i>=int(b);--i)
#define rrep(...) _overload(__VA_ARGS__,_rrange,_rrep,)(__VA_ARGS__)
#define _all(arg) begin(arg),end(arg)
#define uniq(arg) sort(_all(arg)),(arg).erase(unique(_all(arg)),end(arg))
#define getidx(ary,key) lower_bound(_all(ary),key)-begin(ary)
#define clr(a,b) memset((a),(b),sizeof(a))
#define bit(n) (1LL<<(n))
#define popcount(n) (__builtin_popcountll(n))
using namespace std;
template<class T>bool chmax(T &a, const T &b) { return (a < b) ? (a = b, 1) : 0;}
template<class T>bool chmin(T &a, const T &b) { return (b < a) ? (a = b, 1) : 0;}
using ll = long long;
using R = long double;
const R EPS = 1e-9L; // [-1000,1000]->EPS=1e-8 [-10000,10000]->EPS=1e-7
inline int sgn(const R& r) {return (r > EPS) - (r < -EPS);}
inline R sq(R x) {return sqrt(max(x, 0.0L));}
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
// Problem Specific Parameter:
const int limit = 100010;
int a[limit];
multiset<int> ord, rev;
int main(void) {
int n;
cin >> n;
rep(i, n) cin >> a[i];
vector<int> ans;
rep(i, n) {
const int ridx = n - 1 - i;
{
auto it = rev.find(a[i]);
if(it != end(rev)){
rev.erase(it);
}else{
ord.insert(a[i]);
}
}
{
auto it = ord.find(a[ridx]);
if(it != end(ord)){
ord.erase(it);
}else{
rev.insert(a[ridx]);
}
}
if(ord.empty() and rev.empty()) ans.push_back(i + 1);
}
const int m = ans.size();
rep(i,m) cout << (i?" ":"") << ans[i];
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define MOD 1000000007LL
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
int n;
int a[100001];
vector<int> vec;
int cnt[100001];
int main(void){
scanf("%d",&n);
for(int i=0;i<n;i++){
scanf("%d",&a[i]);
vec.push_back(a[i]);
}
sort(vec.begin(),vec.end());
vec.erase(unique(vec.begin(),vec.end()),vec.end());
for(int i=0;i<n;i++){
a[i]=lower_bound(vec.begin(),vec.end(),a[i])-vec.begin();
}
int now=0;
bool po=false;
for(int i=0;i<n;i++){
cnt[a[i]]++;
if(cnt[a[i]]==1)now++;
if(cnt[a[i]]==0)now--;
cnt[a[n-1-i]]--;
if(cnt[a[n-1-i]]==-1)now++;
if(cnt[a[n-1-i]]==0)now--;
if(now==0){
if(po)printf(" ");
po=true;
printf("%d",i+1);
}
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
#include<iostream>
#include<cstdio>
#include<vector>
#include<queue>
#include<map>
#include<cstring>
#include<string>
#include <math.h>
#include<algorithm>
// #include <boost/multiprecision/cpp_int.hpp>
#include<functional>
#define int long long
#define inf 1000000007
#define pa pair<int,int>
#define ll long long
#define pal pair<double,double>
#define ppap pair<pa,int>
#define ssa pair<string,int>
#define mp make_pair
#define pb push_back
#define EPS (1e-10)
#define equals(a,b) (fabs((a)-(b))<EPS)
int dx[4]={0,-1,0,1};
int dy[4]={1,0,-1,0};
using namespace std;
class pa3{
public:
int x,y,z;
pa3(int x=0,int y=0,int z=0):x(x),y(y),z(z) {}
bool operator < (const pa3 &p) const{
if(x!=p.x) return x<p.x;
if(y!=p.y) return y<p.y;
return z<p.z;
//return x != p.x ? x<p.x: y<p.y;
}
bool operator > (const pa3 &p) const{
if(x!=p.x) return x>p.x;
if(y!=p.y) return y>p.y;
return z>p.z;
//return x != p.x ? x<p.x: y<p.y;
}
bool operator == (const pa3 &p) const{
return x==p.x && y==p.y && z==p.z;
}
bool operator != (const pa3 &p) const{
return !( x==p.x && y==p.y && z==p.z);
}
};
class pa4{
public:
double x;
int y,z,w;
pa4(double x=0,int y=0,int z=0,int w=0):x(x),y(y),z(z),w(w) {}
bool operator < (const pa4 &p) const{
if(x!=p.x) return x<p.x;
if(y!=p.y) return y<p.y;
if(z!=p.z)return z<p.z;
return w<p.w;
//return x != p.x ? x<p.x: y<p.y;
}
bool operator > (const pa4 &p) const{
if(x!=p.x) return x>p.x;
if(y!=p.y) return y>p.y;
if(z!=p.z)return z>p.z;
return w>p.w;
//return x != p.x ? x<p.x: y<p.y;
}
bool operator == (const pa4 &p) const{
return x==p.x && y==p.y && z==p.z &&w==p.w;
}
};
class pa2{
public:
int x,y;
pa2(int x=0,int y=0):x(x),y(y) {}
pa2 operator + (pa2 p) {return pa2(x+p.x,y+p.y);}
pa2 operator - (pa2 p) {return pa2(x-p.x,y-p.y);}
pa2 operator * (int a) {return pa2(x*a,y*a);}
bool operator < (const pa2 &p) const{
return x != p.x ? x<p.x: y<p.y;
}
bool operator > (const pa2 &p) const{
return x != p.x ? x>p.x: y>p.y;
}
bool operator == (const pa2 &p) const{
return abs(x-p.x)==0 && abs(y-p.y)==0;
}
bool operator != (const pa2 &p) const{
return !(abs(x-p.x)==0 && abs(y-p.y)==0);
}
};
#define ppa pair<int,pas>
class Point{
public:
double x,y;
Point(double x=0,double y=0):x(x),y(y) {}
Point operator + (Point p) {return Point(x+p.x,y+p.y);}
Point operator - (Point p) {return Point(x-p.x,y-p.y);}
Point operator * (double a) {return Point(x*a,y*a);}
Point operator / (double a) {return Point(x/a,y/a);}
double absv() {return sqrt(norm());}
double norm() {return x*x+y*y;}
bool operator < (const Point &p) const{
return x != p.x ? x<p.x: y<p.y;
}
bool operator == (const Point &p) const{
return fabs(x-p.x)<EPS && fabs(y-p.y)<EPS;
}
};
typedef Point Vector;
#define pl pair<int,pas>
struct Segment{
Point p1,p2;
};
double dot(Vector a,Vector b){
return a.x*b.x+a.y*b.y;
}
double cross(Vector a,Vector b){
return a.x*b.y-a.y*b.x;
}
bool parareru(Point a,Point b,Point c,Point d){
// if(abs(cross(a-b,d-c))<EPS)cout<<"dd "<<cross(a-b,d-c)<<endl;
return abs(cross(a-b,d-c))<EPS;
}
double distance_ls_p(Point a, Point b, Point c) {
if ( dot(b-a, c-a) < EPS ) return (c-a).absv();
if ( dot(a-b, c-b) < EPS ) return (c-b).absv();
return abs(cross(b-a, c-a)) / (b-a).absv();
}
bool is_intersected_ls(Segment a,Segment b) {
if(a.p1==b.p1||a.p2==b.p1||a.p1==b.p2||a.p2==b.p2) return false;
if(parareru((a.p2),(a.p1),(a.p1),(b.p2))&¶reru((a.p2),(a.p1),(a.p1),(b.p1))){
// cout<<"sss"<<endl;
if(dot(a.p1-b.p1,a.p1-b.p2)<EPS) return true;
if(dot(a.p2-b.p1,a.p2-b.p2)<EPS) return true;
if(dot(a.p1-b.p1,a.p2-b.p1)<EPS) return true;
if(dot(a.p1-b.p2,a.p2-b.p2)<EPS) return true;
return false;
}
else return ( cross(a.p2-a.p1, b.p1-a.p1) * cross(a.p2-a.p1, b.p2-a.p1) < EPS ) && ( cross(b.p2-b.p1, a.p1-b.p1) * cross(b.p2-b.p1, a.p2-b.p1) < EPS );
}
double segment_dis(Segment a,Segment b){
if(is_intersected_ls(a,b))return 0;
double r=distance_ls_p(a.p1, a.p2, b.p1);
r=min(r,distance_ls_p(a.p1, a.p2, b.p2));
r=min(r,distance_ls_p(b.p1, b.p2, a.p2));
r=min(r,distance_ls_p(b.p1, b.p2, a.p1));
return r;
}
Point intersection_ls(Segment a, Segment b) {
Point ba = b.p2-b.p1;
double d1 = abs(cross(ba, a.p1-b.p1));
double d2 = abs(cross(ba, a.p2-b.p1));
double t = d1 / (d1 + d2);
return a.p1 + (a.p2-a.p1) * t;
}
string itos( int i ) {
ostringstream s ;
s << i ;
return s.str() ;
}
int gcd(int v,int b){
if(v>b) return gcd(b,v);
if(v==b) return b;
if(b%v==0) return v;
return gcd(v,b%v);
}
double distans(double x1,double y1,double x2,double y2){
double rr=(x1-x2)*(x1-x2)+(y1-y2)*(y1-y2);
return sqrt(rr);
}
/*
int pr[1000010];
int inv[1000010];
int beki(int wa,int rr,int warukazu){
if(rr==0) return 1%warukazu;
if(rr==1) return wa%warukazu;
if(rr%2==1) return (beki(wa,rr-1,warukazu)*wa)%warukazu;
int zx=beki(wa,rr/2,warukazu);
return (zx*zx)%warukazu;
}
double bekid(double w,int r){
if(r==0) return 1.0;
if(r==1) return w;
if(r%2) return bekid(w,r-1)*w;
double f=bekid(w,r/2);
return f*f;
}
int comb(int nn,int rr){
int r=pr[nn]*inv[rr];
r%=inf;
r*=inv[nn-rr];
r%=inf;
return r;
}
void gya(int ert){
pr[0]=1;
for(int i=1;i<=ert;i++){
pr[i]=(pr[i-1]*i)%inf;
}
for(int i=0;i<=ert;i++) inv[i]=beki(pr[i],inf-2,inf);
}
*/
//priority_queue<pa3,vector<pa3>,greater<pa3>> pq;
//sort(ve.begin(),ve.end(),greater<int>());
//----------------kokomade tenpure------------
//vector<double> ans(100000000),ans2(100000000)
set<int> se;
map<int,int> ma;
string s;
int a[100020];
int d[100020]={0};
vector<int> ans;
signed main(){
int n,m;
cin>>n;
for(int i=0;i<n;i++){
cin>>a[i];
se.insert(a[i]);
}
int cn=1;
for(auto it=se.begin();it!=se.end();it++){
ma[*it]=cn;
cn++;
}
for(int i=0;i<n;i++){
a[i]=ma[a[i]];
// cout<<a[i]<<endl;
}
int sa=0;
for(int i=0;i<n;i++){
d[a[i]]++;
if(d[a[i]]==1)sa++;
if(d[a[i]]==0)sa--;
d[a[n-1-i]]--;
if(d[a[n-1-i]]==0)sa--;
if(d[a[n-1-i]]==-1)sa++;
if(sa==0) ans.pb(i+1);
}
for(int i=0;i<ans.size();i++){
if(i>0)cout<<" ";
cout<<ans[i];
}
cout<<endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
using Int = long long;
//INSERT ABOVE HERE
signed main(){
Int n;
cin>>n;
vector<Int> a(n);
for(Int i=0;i<n;i++) cin>>a[i];
Int ok=0,x=0;
map<Int, Int> m;
for(Int i=0;i<n;i++){
if(m[a[i]]++==0) ok++;
if(m[a[i]]==0) ok--;
if(m[a[n-(i+1)]]--==0) ok++;
if(m[a[n-(i+1)]]==0) ok--;
if(!ok){
if(x) cout<<" ";
x=1;
cout<<i+1;
}
}
cout<<endl;
return 0;
}
|
#include<bits/stdc++.h>
#define REP(i,s,n) for(int i=s;i<n;++i)
#define rep(i,n) REP(i,0,n)
#define ALL(x) x.begin(),x.end()
#define EPS (1e-8)
#define equals(a,b) (fabs((a)-(b))<EPS)
using namespace std;
typedef long long ll;
typedef pair<int,int> ii;
inline bool LT(double a,double b) { return !equals(a,b) && a < b; }
inline bool LTE(double a,double b) { return equals(a,b) || a < b; }
void compute() {
}
int main() {
int n;
cin >> n;
vector<int> a(n);
rep(i,n) {
cin >> a[i];
}
vector<int> ans;
map<int,int> mp;
deque<int> yet;
rep(i,n) {
int r = n-1-i;
++mp[a[r]];
yet.push_back(a[i]);
while( !yet.empty() ) {
if( mp[yet.front()] ) {
mp[yet.front()]--;
yet.pop_front();
} else break;
}
if( yet.empty() ) {
ans.push_back(i);
}
}
/*
if( n % 2 == 1 ) {
if( ans.size() && ans.back() == (int)(n / 2)-1 ) {
ans.push_back(n/2);
}
}
vector<int> b;
rep(i,(int)ans.size()) {
b.push_back(i);
b.push_back(n-1-i);
}
sort(ALL(b));
b.erase(unique(ALL(b)),b.end());
*/
vector<int> b = ans;
rep(i,(int)b.size()) {
if( i ) printf(" ");
cout << b[i]+1;
} puts("");
compute();
return 0;
}
|
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#include <climits>
#define rep(i, m, n) for(int i=int(m);i<int(n);i++)
#define EACH(i, c) for (auto &(i): c)
#define all(c) begin(c),end(c)
#define EXIST(s, e) ((s).find(e)!=(s).end())
#define SORT(c) sort(begin(c),end(c))
#define pb emplace_back
#define MP make_pair
#define SZ(a) int((a).size())
//#define LOCAL 0
//#ifdef LOCAL
//#define DEBUG(s) cout << (s) << endl
//#define dump(x) cerr << #x << " = " << (x) << endl
//#define BR cout << endl;
//#else
//#define DEBUG(s) do{}while(0)
//#define dump(x) do{}while(0)
//#define BR
//#endif
//改造
typedef long long int ll;
using namespace std;
#define INF (1 << 30) - 1
#define INFl (ll)5e15
#define DEBUG 0 //デバッグする時1にしてね
#define dump(x) cerr << #x << " = " << (x) << endl
#define MOD 1000000007
//ここから編集する
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
vector<int> a(N);
rep(i,0,N) cin >> a[i];
map<int,int> mpl,mpr;
vector<int> ans;
for(int l = 0; l < N; l++){
int r = (N - 1) - l;
if(mpr.find(a[l]) != mpr.end()){
if(mpr[a[l]] == 1) mpr.erase(a[l]);
else mpr[a[l]]--;
}else{
mpl[a[l]]++;
}
if(mpl.find(a[r]) != mpl.end() ) {
if(mpl[a[r]] == 1) mpl.erase(a[r]);
else mpl[a[r]]--;
}else{
mpr[a[r]]++;
}
if(mpr.empty() && mpl.empty()){
// cout << l + 1 << " ";
ans.push_back(l+1);
}
}
rep(i,0,ans.size()){
cout << ans[i];
if(i != ans.size() - 1){
cout << " ";
}else{
cout << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
#define REP(i, a, n) for(ll i = ((ll) a); i < ((ll) n); i++)
using namespace std;
typedef long long ll;
int main(void) {
ll N;
cin >> N;
vector<ll> A(N);
REP(i, 0, N) cin >> A[i];
map<ll, ll> mp;
ll cnt = 0;
vector<ll> ans;
REP(i, 0, N) {
ll k = i + 1;
if(mp[A[i]] >= 0) {
cnt++;
} else {
cnt--;
}
mp[A[i]]++;
if(mp[A[N - i - 1]] <= 0) {
cnt++;
} else {
cnt--;
}
mp[A[N - i - 1]]--;
if(cnt == 0) ans.push_back(k);
}
REP(i, 0, ans.size()) cout << ans[i] << (i + 1 != ans.size() ? " " : "\n");
}
|
#include "bits/stdc++.h"
#define in std::cin
#define out std::cout
#define rep(i,N) for(int i=0;i<N;++i)
typedef long long int LL;
LL N;
std::vector<LL>a, ans;
std::map<LL, LL>cou1, cou2;
int main()
{
in >> N;
a.resize(N);
rep(i, N) in >> a[i];
LL diff = 0;
rep(i, N)
{
if (cou1[a[i]] == cou2[a[i]]) --diff;
if (cou1[a[N - i - 1]] == cou2[a[N - i - 1]]) --diff;
++cou1[a[i]]; ++cou2[a[N - i - 1]];
if (cou1[a[i]] == cou2[a[i]]) ++diff;
if (cou1[a[N - i - 1]] == cou2[a[N - i - 1]]) ++diff;
if (diff == 0) ans.push_back(i + 1);
}
rep(i, ans.size() - 1) out << ans[i] << " "; out << ans[ans.size() - 1] << std::endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int (i)=0;(i)<(int)(n);++(i))
#define pb push_back
struct MinSegTree{
int n;
vector<int> dat;
MinSegTree(){}
MinSegTree(int _n){
n = 1;
while(n<_n) n*=2;
dat = vector<int>(2*n-1,INT_MAX);
}
void update(int k, int val){
k += n-1;
dat[k] = val;
while(k>0){
k = (k-1)/2;
dat[k] = min(dat[2*k+1],dat[2*k+2]);
}
}
int _query(int a, int b, int k, int l, int r){
if(r<=a || b<=l) return INT_MAX;
if(a<=l && r<=b) return dat[k];
int vl = _query(a,b,2*k+1,l,(l+r)/2);
int vr = _query(a,b,2*k+2,(l+r)/2,r);
return min(vl,vr);
}
int query(int a, int b){
return _query(a,b,0,0,n);
}
int get(int k)
{
k += n-1;
return dat[k];
}
};
int main()
{
int n;
scanf(" %d", &n);
MinSegTree st[2];
rep(j,2)
{
st[j] = MinSegTree(n);
rep(i,n)
{
int v;
scanf(" %d", &v);
st[j].update(i,v);
}
}
int Q;
scanf(" %d", &Q);
set<int> u;
rep(i,n) u.insert(i);
while(Q--)
{
int x,y,z;
scanf(" %d %d %d", &x, &y, &z);
--y;
if(x==1 || x==2)
{
st[x-1].update(y,z);
u.insert(y);
}
else if(x==3 || x==4)
{
printf("%d\n", st[x-3].query(y,z));
}
else
{
int focus = !(x-5);
// printf(" x= %d focus %d\n", x,focus);
for(int idx:u)
{
// st[x-5].update(idx, st[focus].query(idx,idx+1));
st[x-5].update(idx, st[focus].get(idx));
}
u.clear();
}
// printf(" --- Q %d \n", Q);
// printf(" A:");
// rep(i,n) printf(" %d", st[0].get(i));
// printf("\n");
// printf(" B:");
// rep(i,n) printf(" %d", st[1].get(i));
// printf("\n");
}
return 0;
} |
// need
#include <iostream>
#include <algorithm>
// data structure
#include <bitset>
//#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#include <array>
//#include <tuple>
//#include <unordered_map>
#include <unordered_set>
#include <complex>
//#include <deque>
#include<valarray>
// stream
//#include <istream>
//#include <sstream>
//#include <ostream>
//#include <fstream>
// etc
#include <cmath>
#include <cassert>
#include <functional>
#include <iomanip>
//#include <typeinfo>
#include <chrono>
#include <random>
#include <numeric>
// input
#define INIT std::ios::sync_with_stdio(false);std::cin.tie(0);
#define VAR(type, ...)type __VA_ARGS__;MACRO_VAR_Scan(__VA_ARGS__);
template<typename T> void MACRO_VAR_Scan(T& t) { std::cin >> t; }
template<typename First, typename...Rest>void MACRO_VAR_Scan(First& first, Rest&...rest) { std::cin >> first; MACRO_VAR_Scan(rest...); }
#define VEC_ROW(type, n, ...)std::vector<type> __VA_ARGS__;MACRO_VEC_ROW_Init(n, __VA_ARGS__); for(int i=0; i<n; ++i){MACRO_VEC_ROW_Scan(i, __VA_ARGS__);}
template<typename T> void MACRO_VEC_ROW_Init(int n, T& t) { t.resize(n); }
template<typename First, typename...Rest>void MACRO_VEC_ROW_Init(int n, First& first, Rest&...rest) { first.resize(n); MACRO_VEC_ROW_Init(n, rest...); }
template<typename T> void MACRO_VEC_ROW_Scan(int p, T& t) { std::cin >> t[p]; }
template<typename First, typename...Rest>void MACRO_VEC_ROW_Scan(int p, First& first, Rest&...rest) { std::cin >> first[p]; MACRO_VEC_ROW_Scan(p, rest...); }
#define VEC(type, c, n) std::vector<type> c(n);for(auto& i:c)std::cin>>i;
#define MAT(type, c, m, n) std::vector<std::vector<type>> c(m, std::vector<type>(n));for(auto& r:c)for(auto& i:r)std::cin>>i;
// output
#define OUT(d) std::cout<<d;
#define FOUT(n, d) std::cout<<std::fixed<<std::setprecision(n)<<d;
#define SOUT(n, c, d) std::cout<<std::setw(n)<<std::setfill(c)<<d;
#define SP std::cout<<" ";
#define TAB std::cout<<"\t";
#define BR std::cout<<"\n";
#define SPBR(i, n) std::cout<<(i + 1 == n ? '\n' : ' ');
#define ENDL std::cout<<std::endl;
#define FLUSH std::cout<<std::flush;
#define SHOW(d) {std::cerr << #d << "\t:" << d << "\n";}
#define SHOWVECTOR(v) {std::cerr << #v << "\t:";for(const auto& xxx : v){std::cerr << xxx << " ";}std::cerr << "\n";}
#define SHOWVECTOR2(v) {std::cerr << #v << "\t:\n";for(const auto& xxx : v){for(const auto& yyy : xxx){std::cerr << yyy << " ";}std::cerr << "\n";}}
#define SHOWQUEUE(a) {auto tmp(a);std::cerr << #a << "\t:";while(!tmp.empty()){std::cerr << tmp.front() << " ";tmp.pop();}std::cerr << "\n";}
// utility
#define ALL(a) (a).begin(),(a).end()
#define FOR(i, a, b) for(int i=(a);i<(b);++i)
#define RFOR(i, a, b) for(int i=(b)-1;i>=(a);--i)
#define REP(i, n) for(int i=0;i<int(n);++i)
#define RREP(i, n) for(int i=int(n)-1;i>=0;--i)
#define FORLL(i, a, b) for(ll i=ll(a);i<ll(b);++i)
#define RFORLL(i, a, b) for(ll i=ll(b)-1;i>=ll(a);--i)
#define REPLL(i, n) for(ll i=0;i<ll(n);++i)
#define RREPLL(i, n) for(ll i=ll(n)-1;i>=0;--i)
#define IN(a, x, b) (a<=x && x<b)
template<typename T> inline T CHMAX(T& a, const T b) { return a = (a < b) ? b : a; }
template<typename T> inline T CHMIN(T& a, const T b) { return a = (a > b) ? b : a; }
#define EXCEPTION(msg) throw std::string("Exception : " msg " [ in ") + __func__ + " : " + std::to_string(__LINE__) + " lines ]"
#define TRY(cond, msg) try {if (cond) EXCEPTION(msg);}catch (std::string s) {std::cerr << s << std::endl;}
void CHECKTIME(std::function<void()> f) { auto start = std::chrono::system_clock::now(); f(); auto end = std::chrono::system_clock::now(); auto res = std::chrono::duration_cast<std::chrono::nanoseconds>((end - start)).count(); std::cerr << "[Time:" << res << "ns (" << res / (1.0e9) << "s)]\n"; }
// test
template<class T> std::vector<std::vector<T>> VV(int n) {
return std::vector<std::vector<T>>(n);
}
template<class T> std::vector<std::vector<T>> VV(int n, int m, T init = T()) {
return std::vector<std::vector<T>>(n, std::vector<T>(m, init));
}
template<typename S, typename T>
std::ostream& operator<<(std::ostream& os, std::pair<S, T> p) {
os << "(" << p.first << ", " << p.second << ")"; return os;
}
// type/const
//#define int ll
using ll = long long;
using ull = unsigned long long;
using PAIR = std::pair<int, int>;
using PAIRLL = std::pair<ll, ll>;
constexpr int INFINT = 1 << 30; // 1.07x10^ 9
constexpr int INFINT_LIM = (1LL << 31) - 1; // 2.15x10^ 9
constexpr ll INFLL = 1LL << 60; // 1.15x10^18
constexpr ll INFLL_LIM = (1LL << 62) - 1 + (1LL << 62); // 9.22x10^18
constexpr double EPS = 1e-7;
constexpr int MOD = 1000000007;
constexpr double PI = 3.141592653589793238462643383279;
//SegmentTree(?????°??¨)
template <class T>
class SegmentTree {
private:
T init_val;
std::vector<T> ary;
std::function<T(T, T)> func;
public:
// ?????¨???(??????????????§??????n??¨??????)
// SegmentTree<int> st(n, INFLL, [](int l, int r){return std::min(l, r);}); ????°????
// SegmentTree<int> st(n, -INFLL, [](int l, int r){return std::max(l, r);}); ?????§???
// SegmentTree<int> st(n, 0, [](int l, int r){return l+r;}); ????¨?
SegmentTree(int n, T val, std::function<T(T, T)> f) : init_val(val), func(f) {
ary.resize(static_cast<int>(std::pow(2, std::ceil(std::log(n) / std::log(2)) + 1) - 1), val);
}
void init(int n, T val, std::function<T(T, T)> f) {
ary.resize(static_cast<int>(std::pow(2, std::ceil(1.0*std::log(n) / std::log(2)) + 1) - 1), val);
init_val = val;
func = f;
}
void update(int i, T val) {
i += ary.size() / 2;
ary[i] = val;
while (i > 0) {
i = (i - 1) / 2;
ary[i] = func(ary[2 * i + 1], ary[2 * i + 2]);
}
}
// ??????[a, b)???func????????????????????? (query_(a, b, 0, 0, n)??¨????????????)
T query_(int a, int b, int i, int l, int r) {
if (r <= a || b <= l) return init_val;
if (a <= l && r <= b) return ary[i];
else {
T vl = query_(a, b, 2 * i + 1, l, (l + r) / 2);
T vr = query_(a, b, 2 * i + 2, (l + r) / 2, r);
return func(vl, vr);
}
}
// ??????(b)????°??????§?????????????????????
T query(int a, int b) {
return query_(a, b, 0, 0, ary.size() / 2 + 1);
}
T operator[](int i) {
return query(i, i + 1);
}
};
signed main() {
INIT;
VAR(int, n);
VEC(int, a, n);
VEC(int, b, n);
SegmentTree<int> A(n, INFINT, [](int l, int r) {return std::min(l, r); });
SegmentTree<int> B(n, INFINT, [](int l, int r) {return std::min(l, r); });
REP(i, n) {
A.update(i, a[i]);
B.update(i, b[i]);
}
bool copy = false;
VAR(int, Q);
std::set<int> set;
REP(_, Q) {
VAR(int, x, y, z);
--y;
if (x == 1) {
A.update(y, z);
if (copy) set.insert(y);
}
else if (x == 2) {
B.update(y, z);
if (copy) set.insert(y);
}
else if (x == 3) {
OUT(A.query(y, z))BR;
}
else if (x == 4) {
OUT(B.query(y, z))BR;
}
else if (x == 5) {
if (copy) {
for (auto i : set) {
A.update(i, B[i]);
}
}
else {
REP(i, n) {
A.update(i, B[i]);
}
copy = true;
}
set.clear();
}
else if (x == 6) {
if (copy) {
for (auto i : set) {
B.update(i, A[i]);
}
}
else {
REP(i, n) {
B.update(i, A[i]);
}
copy = true;
}
set.clear();
}
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
template< typename T >
struct SegmentTree
{
const T INF;
vector< T > seg;
int sz;
SegmentTree(int n) : INF(numeric_limits< T >::max())
{
sz = 1;
while(sz < n) sz <<= 1;
seg.assign(2 * sz - 1, INF);
}
T merge(T a, T b)
{
return (min(a, b));
}
void set(int k, int x)
{
seg[k + sz - 1] = x;
}
void build()
{
for(int k = sz - 2; k >= 0; k--) {
seg[k] = merge(seg[2 * k + 1], seg[2 * k + 2]);
}
}
T rmq(int a, int b, int k, int l, int r)
{
if(a >= r || b <= l) return (INF);
if(a <= l && r <= b) return (seg[k]);
return (merge(rmq(a, b, 2 * k + 1, l, (l + r) >> 1),
rmq(a, b, 2 * k + 2, (l + r) >> 1, r)));
}
T rmq(int a, int b)
{
return (rmq(a, b, 0, 0, sz));
}
void update(int k, T x)
{
k += sz - 1;
seg[k] = x;
while(k > 0) {
k = (k - 1) >> 1;
seg[k] = merge(seg[2 * k + 1], seg[2 * k + 2]);
}
}
};
int main()
{
int N, A[200000], B[200000];
scanf("%d", &N);
for(int i = 0; i < N; i++) scanf("%d", &A[i]);
for(int i = 0; i < N; i++) scanf("%d", &B[i]);
SegmentTree< int > seg1(N), seg2(N);
for(int i = 0; i < N; i++) seg1.set(i, A[i]);
for(int i = 0; i < N; i++) seg2.set(i, B[i]);
seg1.build();
seg2.build();
int Q;
scanf("%d", &Q);
bool first = false;
vector< pair< int, int > > aa, bb, cc, dd;
while(Q--) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
--b;
if(a == 1) cc.emplace_back(b, seg1.rmq(b, b + 1)), seg1.update(b, c), aa.emplace_back(b, c);
if(a == 2) dd.emplace_back(b, seg2.rmq(b, b + 1)), seg2.update(b, c), bb.emplace_back(b, c);
if(a == 3) printf("%d\n", seg1.rmq(b, c));
if(a == 4) printf("%d\n", seg2.rmq(b, c));
if(a == 5) {
if(!first) {
for(int i = 0; i < N; i++) seg1.update(i, seg2.rmq(i, i + 1));
} else {
reverse(begin(cc), end(cc));
for(auto &p : cc) seg1.update(p.first, p.second);
for(auto &p : bb) seg1.update(p.first, p.second);
}
first = true;
aa.clear();
bb.clear();
cc.clear();
dd.clear();
}
if(a == 6) {
if(!first) {
for(int i = 0; i < N; i++) seg2.update(i, seg1.rmq(i, i + 1));
} else {
reverse(begin(dd), end(dd));
for(auto &p : dd) seg2.update(p.first, p.second);
for(auto &p : aa) seg2.update(p.first, p.second);
}
first = true;
aa.clear();
bb.clear();
cc.clear();
dd.clear();
}
}
} |
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <complex>
#include <string>
#include <sstream>
#include <algorithm>
#include <numeric>
#include <vector>
#include <queue>
#include <stack>
#include <functional>
#include <iostream>
#include <map>
#include <set>
#include <cassert>
using namespace std;
typedef pair<int,int> P;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
#define pu push
#define pb push_back
#define mp make_pair
#define eps 1e-9
#define INF 2000000000
#define sz(x) ((int)(x).size())
#define fi first
#define sec second
#define SORT(x) sort((x).begin(),(x).end())
#define all(x) (x).begin(),(x).end()
#define rep(i,n) for(int (i)=0;(i)<(int)(n);(i)++)
#define repn(i,a,n) for(int (i)=(a);(i)<(int)(n);(i)++)
#define EQ(a,b) (abs((a)-(b))<eps)
typedef int val_t;
const int memory_limit = 8000000;
struct RBST{
struct Node{
Node *lp,*rp;
int size;
val_t val;
val_t mini;
Node(){}
Node(val_t v):val(v),mini(v),size(1),lp(NULL),rp(NULL){}
Node(Node* x):val(x->val),mini(x->mini),size(x->size),lp(x->lp),rp(x->rp){}
};
Node *root;
RBST():root(NULL),memory_size(0){}
Node pool[memory_limit+10000];
int memory_size;
val_t str[400100];
int length_limit;
int id;
int size(Node *x){return !x?0:x->size;}
val_t min_(Node *x){return !x?INF:x->mini;}
Node* update(Node *x){
if(x==NULL)return x;
x->size = 1+size(x->lp)+size(x->rp);
x->mini = min(x->val,min(min_(x->lp),min_(x->rp)));
return x;
}
Node* alloc(val_t val){
return &(pool[memory_size++]=Node(val));
}
Node* copy(Node* x){
return &(pool[memory_size++]=Node(x));
}
Node* merge(Node* x,Node* y){
if(x==NULL)return y;
if(y==NULL)return x;
int m = x->size , n = y->size;
if(rand()%(m+n)<m){
x = copy(x);
x->rp = merge(x->rp,y);
return update(x);
}else{
y = copy(y);
y->lp = merge(x,y->lp);
return update(y);
}
}
Node* merge_(Node* x,Node* y){
if(x==NULL)return y;
if(y==NULL)return x;
int m = x->size , n = y->size;
if(rand()%(m+n)<m){
x->rp = merge(x->rp,y);
return update(x);
}else{
y->lp = merge(x,y->lp);
return update(y);
}
}
typedef pair<Node*,Node*> Np;
Np split(Node *x,int k){ //[0,k),[k,n)
if(x==NULL)return Np(NULL,NULL);
//assert(k<=(x->size));
x = copy(x);
if(k<=size(x->lp)){
Np s = split(x->lp,k);
x->lp = s.sec;
return mp(s.fi,update(x));
}else{
Np s = split(x->rp,k-size(x->lp)-1);
x->rp = s.fi;
return mp(update(x),s.sec);
}
}
void insert(int k,val_t val){ // 0-indexed
Np s = split(root,k);
root = merge(merge(s.fi,alloc(val)),s.sec);
return;
}
val_t erase(int k){ // 0-indexed
Np s = split(root,k);
Np s2 = split(s.sec,1);
root = merge(s.fi,s2.sec);
return s2.fi->val;
}
val_t query(int l,int r){//[l,r)
Np s = split(root,l);
Np s2 = split(s.sec,r-l);
val_t ret = min_(s2.fi);
root = merge(merge(s.fi,s2.fi),s2.sec);
return ret;
}
void copypaste(int a,int b,int c){ // 0-indexed [a,b)
Np s = split(root,a);
Np s2 = split(s.sec,b-a);
Np s3 = split(root,c);
root = merge(merge(s3.fi,s2.fi),s3.sec);
if(size(root)>length_limit)root = split(root,length_limit).fi;
return;
}
void copy_query1(int sz){
Np s = split(root,sz);
Np s2 = split(root,sz);
root = merge(s2.sec,s.sec);
}
void copy_query2(int sz){
Np s = split(root,sz);
Np s2 = split(root,sz);
root = merge(s.fi,s2.fi);
}
void write(Node *x){
if(x==NULL)return;
write(x->lp);
str[id++]=x->val;
write(x->rp);
}
void output(Node *x){
if(x==NULL)return;
printf("[");
output(x->lp);
printf("%d",x->val);
output(x->rp);
printf("]");
}
void build(){
memory_size=0;
root=NULL;
for(int i=0;i<length_limit;i++)root=merge_(root,alloc(str[i]));
}
void rebuild(){
id=0;
write(root);
//assert(id==length_limit);
build();
}
void show(){
str[id]=-1;
for(int i=0;i<length_limit;i++)printf("%d ",str[i]);
printf("\n");
}
}tree;
int main(){
int N;
scanf("%d",&N);
tree.length_limit = 2*N;
for(int i=0;i<N;i++)scanf("%d",&tree.str[i]);
for(int i=0;i<N;i++)scanf("%d",&tree.str[i+N]);
tree.build();
/*for(int i=0;i<2*N;i++){
int a;
scanf("%d",&a);
tree.insert(i,a);
//tree.output(tree.root);
printf("\n");
}*/
int Q;
scanf("%d",&Q);
for(int i=0;i<Q;i++){
int type,y,z;
scanf("%d",&type);
scanf("%d %d",&y,&z);
y--;
if(type==1){
tree.erase(y);
tree.insert(y,z);
//tree.output(tree.root);
//printf("\n");
}else if(type==2){
tree.erase(y+N);
tree.insert(y+N,z);
}else if(type==3){
printf("%d\n",tree.query(y,z));
}else if(type==4){
printf("%d\n",tree.query(y+N,z+N));
}else if(type==5){
tree.copy_query1(N);
//tree.output(tree.root);
}else{
tree.copy_query2(N);
//tree.output(tree.root);
}
if(tree.memory_size>memory_limit)tree.rebuild();
}
return 0;
} |
#include<deque>
#include<queue>
#include<vector>
#include<algorithm>
#include<iostream>
#include<set>
#include<cmath>
#include<tuple>
#include<string>
#include<chrono>
#include<functional>
#include<iterator>
#include<random>
#include<unordered_set>
#include<unordered_map>
#include<array>
#include<map>
#include<iomanip>
//<< setprecision(5)
using namespace std;
typedef long long int llint;
typedef long double lldo;
#define mp make_pair
#define mt make_tuple
#define pub push_back
#define puf push_front
#define pob pop_back
#define pof pop_front
#define fir first
#define sec second
#define res resize
#define ins insert
#define era erase
#define dme cout<<-1<<endl;return 0
const int mod=1000000007;
const int big=1e9+10;
const long double pai=3.141592653589793238462643383279502884197;
const long double eps=1e-7;
template <class T,class U>void mineq(T& a,U b){if(a>b){a=b;}}
template <class T,class U>void maxeq(T& a,U b){if(a<b){a=b;}}
llint gcd(llint a,llint b){if(a%b==0){return b;}else return gcd(b,a%b);}
llint lcm(llint a,llint b){return a/gcd(a,b)*b;}
class seg{public:
int val;
int seghi,segmg;
seg *left,*right;
seg(int hi,int mg){
left=nullptr;right=nullptr;val=0;
seghi=hi;segmg=mg;
if(hi+1==mg){return;}
left=new seg(hi,(hi+mg)/2);
right=new seg((hi+mg)/2,mg);
}
int ask(int hi,int mg){
if(hi<=seghi&&segmg<=mg){return val;}
if(mg<=seghi||segmg<=hi){return big;}
return min(left->ask(hi,mg),right->ask(hi,mg));
}
void kou(int bas,int num){
if(seghi==bas&&seghi+1==segmg){val=num;return;}
if(bas<(seghi+segmg)/2){left->kou(bas,num);}
else{right->kou(bas,num);}
val=min(left->val,right->val);
}
};
int main(void){
int i,j,n;cin>>n;
seg A(0,n);
seg B(0,n);
vector<int>re;//??´??°?????????????¨??????????????????´??°????????????
for(i=0;i<n;i++){int a;cin>>a;A.kou(i,a);}
for(i=0;i<n;i++){int a;cin>>a;B.kou(i,a);}
for(i=0;i<n;i++){re.pub(i);}
int q;cin>>q;
while(q--){
int x,y,z;cin>>x>>y>>z;
if(x==1){A.kou(y-1,z);re.pub(y-1);}
if(x==2){B.kou(y-1,z);re.pub(y-1);}
if(x==3){cout<<A.ask(y-1,z)<<endl;}
if(x==4){cout<<B.ask(y-1,z)<<endl;}
if(x==5){
for(i=0;i<re.size();i++){
A.kou(re[i],B.ask(re[i],re[i]+1));
}
re.clear();
}
if(x==6){
for(i=0;i<re.size();i++){
B.kou(re[i],A.ask(re[i],re[i]+1));
}
re.clear();
}
}
return 0;
} |
#include <stdio.h>
#include <cmath>
#include <algorithm>
#include <cfloat>
#include <stack>
#include <queue>
#include <vector>
#include <string>
#include <iostream>
#include <set>
#include <map>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
#define NUM 2147483647
enum TREE{
A,
B,
};
struct Info{
Info(int arg_loc,TREE arg_tree){
loc = arg_loc;
tree = arg_tree;
}
int loc;
TREE tree;
};
int N;
int table[2][526000];
void init(int first_N){
while(N < first_N)N *= 2;
}
void update(TREE tree,int loc,int value){
loc += N-1;
table[tree][loc] = value;
if(N == 1)return;
int parent = (loc-1)/2;
while(true){
table[tree][parent] = min(table[tree][2*parent+1],table[tree][2*parent+2]);
if(parent == 0)break;
else{
parent = (parent-1)/2;
}
}
}
int query(TREE tree,int search_left,int search_right,int node_id,int node_left,int node_right){
if(search_right < node_left || search_left > node_right)return NUM;
if(search_left <= node_left && search_right >= node_right){
return table[tree][node_id];
}
int left_min = query(tree,search_left,search_right,2*node_id+1,node_left,(node_left+node_right)/2);
int right_min = query(tree,search_left,search_right,2*node_id+2,(node_left+node_right)/2+1,node_right);
return min(left_min,right_min);
}
int main(){
int first_N;
N = 1;
scanf("%d",&first_N);
init(first_N);
for(int i = 0; i <= 2*N-2; i++){
table[A][i] = NUM;
table[B][i] = NUM;
}
int tmp;
for(int i = 0; i < first_N; i++){
scanf("%d",&tmp);
update(A,i,tmp);
}
for(int i = 0; i < first_N; i++){
scanf("%d",&tmp);
update(B,i,tmp);
}
int Q;
scanf("%d",&Q);
int x,y,z;
bool is_First = true;
queue<Info> update_LOG;
for(int loop = 0; loop < Q; loop++){
scanf("%d %d %d",&x,&y,&z);
switch(x){
case 1:
update(A,y-1,z);
update_LOG.push(Info(y-1,A));
break;
case 2:
update(B,y-1,z);
update_LOG.push(Info(y-1,B));
break;
case 3:
printf("%d\n",query(A,y-1,z-1,0,0,N-1));
break;
case 4:
printf("%d\n",query(B,y-1,z-1,0,0,N-1));
break;
case 5:
if(is_First){
while(!update_LOG.empty())update_LOG.pop();
for(int i = 0; i < N; i++){
update(A,i,table[B][N-1+i]);
}
is_First = false;
}else{
while(!update_LOG.empty()){
update(A,update_LOG.front().loc,table[B][N-1+update_LOG.front().loc]);
update_LOG.pop();
}
}
break;
case 6:
if(is_First){
while(!update_LOG.empty())update_LOG.pop();
for(int i = 0; i < N; i++){
update(B,i,table[A][N-1+i]);
}
is_First = false;
}else{
while(!update_LOG.empty()){
update(B,update_LOG.front().loc,table[A][N-1+update_LOG.front().loc]);
update_LOG.pop();
}
}
break;
}
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
#define fi first
#define se second
#define repl(i,a,b) for(ll i=(ll)(a);i<(ll)(b);i++)
#define rep(i,n) repl(i,0,n)
#define each(itr,v) for(auto itr:v)
#define pb push_back
#define all(x) (x).begin(),(x).end()
#define dbg(x) cout<<#x"="<<x<<endl
#define mmax(x,y) (x>y?x:y)
#define mmin(x,y) (x<y?x:y)
#define maxch(x,y) x=mmax(x,y)
#define minch(x,y) x=mmin(x,y)
#define uni(x) x.erase(unique(all(x)),x.end())
#define exist(x,y) (find(all(x),y)!=x.end())
#define bcnt __builtin_popcount
#define INF 1e16
struct RangeMinQuery{
ll dat[(1<<19)-1];
int size;
void init(int n_){
size=1;
while(size<n_) size*=2;
for(int i=0;i<2*size-1;i++)dat[i]=INF;
}
void update(int k,ll a){
k+=size-1;
dat[k]=a;
while(k>0){
k=(k-1)/2;
dat[k]=min(dat[k*2+1],dat[k*2+2]);
}
}
ll subquery(int a,int b,int k,int l,int r){
if(r<=a||b<=l)return INF;
if(a<=l&&r<=b)return dat[k];
else{
return min(subquery(a,b,k*2+1,l,(l+r)/2),subquery(a,b,k*2+2,(l+r)/2,r));
}
}
ll query(int a,int b){
return subquery(a,b,0,0,size);
}
};
ll n;
ll a[201010],b[201010];
vector<ll> ch;
RangeMinQuery rmq[2];
int main(){
cin>>n;
rep(i,n)cin>>a[i];
rep(i,n)cin>>b[i];
rmq[0].init(n); rmq[1].init(n);
ll q;
cin>>q;
bool oc=false;
rep(i,n)rmq[0].update(i,a[i]);
rep(i,n)rmq[1].update(i,b[i]);
while(q--){
ll x;
cin>>x;
if(x==1||x==2){
x--;
ll y,z;
cin>>y>>z;
y--;
if(!oc){
rmq[x].update(y,z);
}else{
rmq[x].update(y,z);
ch.push_back(y);
}
}else if(x==3||x==4){
ll y,z;
cin>>y>>z;
x-=3;
y--;
cout<<rmq[x].query(y,z)<<endl;
}else{
x-=5;
ll y,z;
cin>>y>>z;
if(!oc){
oc=true;
rep(i,n){
rmq[x].update(i,rmq[1-x].query(i,i+1));
}
}else{
rep(i,ch.size()){
rmq[x].update(ch[i],rmq[1-x].query(ch[i],ch[i]+1));
}
ch.clear();
}
}
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,n) for(int (i)=0;(i)<(int)(n);++(i))
#define all(x) (x).begin(),(x).end()
#define pb push_back
#define fi first
#define se second
#define dbg(x) cout<<#x" = "<<((x))<<endl
template<class T,class U> ostream& operator<<(ostream& o, const pair<T,U> &p){o<<"("<<p.fi<<","<<p.se<<")";return o;}
template<class T> ostream& operator<<(ostream& o, const vector<T> &v){o<<"[";for(T t:v){o<<t<<",";}o<<"]";return o;}
struct SegTree{
int n; vector<ll> dat;
//初期化
SegTree(){}
SegTree(int _n){
n=1;
while(n<_n) n*=2;
dat=vector<ll>(2*n-1,LLONG_MAX);
}
ll get(int k){
return dat[k+n-1];
}
//k番目(0-indexed)の値をaに変更
void update(int k, ll a){
k+=n-1;
dat[k]=a;
//更新
while(k>0){
k=(k-1)/2;
dat[k]=min(dat[2*k+1],dat[2*k+2]);
}
}
//内部的に投げられるクエリ
ll _query(int a, int b, int k, int l, int r){
if(r<=a || b<=l) return LLONG_MAX;
if(a<=l && r<=b) return dat[k];
ll vl=_query(a,b,2*k+1,l,(l+r)/2);
ll vr=_query(a,b,2*k+2,(l+r)/2,r);
return min(vl,vr);
}
//[a,b)
ll query(int a, int b){
return _query(a,b,0,0,n);
}
};
int main(){
int n;
scanf(" %d", &n);
SegTree t[2];
rep(i,2){
t[i] = SegTree(n);
rep(j,n){
int x;
scanf(" %d", &x);
t[i].update(j,x);
}
}
set<int> upd;
rep(i,n) upd.insert(i);
int Q;
scanf(" %d", &Q);
while(Q--){
int x,y,z;
scanf(" %d %d %d", &x, &y, &z);
if(x<=2){
x -= 1;
t[x].update(y-1,z);
upd.insert(y-1);
}
else if(x<=4){
x -= 3;
printf("%lld\n", t[x].query(y-1,z));
}
else{
x -= 5;
for(int idx:upd) t[x].update(idx, t[!x].get(idx));
upd.clear();
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using lint = long long;
template<class T = int> using V = vector<T>;
template<class T = int> using VV = V< V<T> >;
template<class Z> Z rng(Z a, Z b) {
static mt19937 mt(chrono::steady_clock::now().time_since_epoch().count());
return uniform_int_distribution<Z>(a, b - 1)(mt);
}
namespace PersistentRandomizedBinarySearchTree {
using T = int;
static T op(const T& a, const T& b) { return min(a, b); }
static constexpr T e() { return 2e9; }
using U = char;
static T ap(const U& f, T a) { return a; }
static U cp(const U& g, U f) { return f; }
static constexpr U id() { return 0; }
static T op(const T& a, const T& b, const T& c) { return op(op(a, b), c); }
struct Node;
using Tree = shared_ptr<Node>;
struct Node {
int sz = 0, h = 0;
Tree lch = nullptr, rch = nullptr;
T val = e(), acc = e();
U laz = id();
bool rev = false;
Node() {}
Node(Tree lch, Tree rch, const T& val, const T& acc, const U& laz = id(), bool rev = false) :
sz(lch->sz + 1 + rch->sz), h(max(lch->h, rch->h) + 1), lch(lch), rch(rch), val(val), acc(acc), laz(laz), rev(rev) {}
};
Tree nil = make_shared<Node>();
Tree apply(Tree t, const U& f) {
return make_shared<Node>(t->lch, t->rch, ap(f, t->val), ap(f, t->acc), cp(f, t->laz), t->rev);
}
Tree reverse(Tree t) {
return make_shared<Node>(t->rch, t->lch, t->val, t->acc, t->laz, !t->rev);
}
void push(Tree t) {
if (!(t->laz == id())) {
t->lch->val = ap(t->laz, t->lch->val);
t->lch->acc = ap(t->laz, t->lch->acc);
t->lch->laz = cp(t->laz, t->lch->laz);
t->rch->val = ap(t->laz, t->rch->val);
t->rch->acc = ap(t->laz, t->rch->acc);
t->rch->laz = cp(t->laz, t->rch->laz);
t->laz = id();
}
if (t->rev) {
swap(t->lch->lch, t->lch->rch);
t->lch->rev ^= true;
swap(t->rch->lch, t->rch->rch);
t->rch->rev ^= true;
t->rev = false;
}
}
Tree update(Tree t, Tree lch, Tree rch) {
return make_shared<Node>(lch, rch, t->val, op(lch->acc, t->val, rch->acc));
}
template<class Itr> Tree build(Itr first, Itr last) {
int n = distance(first, last);
if (!n) return nil;
Itr middle = next(first, n >> 1);
Tree lch = build(first, middle), rch = build(next(middle), last);
return make_shared<Node>(lch, rch, *middle, op(lch->acc, *middle, rch->acc));
}
template<class Itr> Itr dump(Tree t, Itr res) {
if (t == nil) return res;
push(t);
res = dump(t->lch, res);
*res++ = t->val;
return dump(t->rch, res);
}
Tree rebuild(Tree t) {
V<T> v(t->sz);
dump(t, begin(v));
return build(begin(v), end(v));
}
Tree merge(Tree l, Tree r) {
if (l == nil) return r;
if (r == nil) return l;
if (rng(0, l->sz + r->sz) < l->sz) {
push(l);
return update(l, l->lch, merge(l->rch, r));
} else {
push(r);
return update(r, merge(l, r->lch), r->rch);
}
}
Tree merge(Tree l, Tree m, Tree r) { return merge(merge(l, m), r); }
pair<Tree, Tree> split(Tree t, int i) {
assert(0 <= i and i <= t->sz);
if (t == nil) return {nil, nil};
push(t);
if (i <= t->lch->sz) {
Tree l, lch;
tie(l, lch) = split(t->lch, i);
return {l, update(t, lch, t->rch)};
} else {
Tree r, rch;
tie(rch, r) = split(t->rch, i - t->lch->sz - 1);
return {update(t, t->lch, rch), r};
}
}
tuple<Tree, Tree, Tree> split(Tree t, int l, int r) {
assert(0 <= l and l <= r and r <= t->sz);
Tree lt, mt, rt;
tie(lt, rt) = split(t, r);
tie(lt, mt) = split(lt, l);
return make_tuple(lt, mt, rt);
}
Tree insert(Tree t, int i, const T& a) {
assert(0 <= i and i <= t->sz);
Tree l, r;
tie(l, r) = split(t, i);
return merge(l, make_shared<Node>(nil, nil, a, a), r);
}
Tree erase(Tree t, int i) {
assert(0 <= i and i < t->sz);
Tree l, r;
tie(l, ignore, r) = split(t, i, i + 1);
return merge(l, r);
}
T get(Tree t, int i) {
assert(0 <= i and i < t->sz);
if (i == t->lch->sz) return t->val;
push(t);
if (i < t->lch->sz) return get(t->lch, i);
else return get(t->rch, i - t->lch->sz - 1);
}
Tree set(Tree t, int i, const T& a) {
assert(0 <= i and i < t->sz);
push(t);
if (i == t->lch->sz) {
return make_shared<Node>(t->lch, t->rch, a, op(t->lch->acc, a, t->rch->acc));
} else if (i < t->lch->sz) {
return update(t, set(t->lch, i, a), t->rch);
} else {
return update(t, t->lch, set(t->rch, i - t->lch->sz - 1, a));
}
}
T acc(Tree t, int l, int r) {
if (l <= 0 and t->sz <= r) return t->acc;
push(t);
T resl = l < t->lch->sz ? acc(t->lch, l, r) : e();
T resr = t->lch->sz + 1 < r ? acc(t->rch, l - t->lch->sz - 1, r - t->lch->sz - 1) : e();
T resm = l <= t->lch->sz and t->lch->sz < r ? t->val : e();
return op(resl, resm, resr);
}
Tree act(Tree t, int l, int r, const U& f) {
if (l <= 0 and t->sz <= r) return apply(t, f);
push(t);
Tree lch = nil, rch = nil;
T val = e();
if (l < t->lch->sz) lch = act(t->lch, l, r, f);
if (t->lch->sz + 1 < r) rch = act(t->rch, l - t->lch->sz - 1, r - t->lch->sz - 1, f);
if (l <= t->lch->sz and t->lch->sz < r) val = ap(f, t->val);
return make_shared<Node>(lch, rch, val, op(lch->acc, val, rch->acc));
}
Tree reverse(Tree t, int l, int r) {
Tree lt, mt, rt;
tie(lt, mt, rt) = split(t, l, r);
return merge(lt, reverse(mt), rt);
}
int lower_bound(Tree t, const T& a) {
if (t == nil) return 0;
push(t);
if (t->val < a) return t->lch->sz + 1 + lower_bound(t->rch, a);
else return lower_bound(t->lch, a);
}
int upper_bound(Tree t, const T& a) {
if (t == nil) return 0;
push(t);
if (a < t->val) return upper_bound(t->lch, a);
else return t->lch->sz + 1 + upper_bound(t->rch, a);
}
int count(Tree t, const T& a) { return upper_bound(t, a) - lower_bound(t, a); }
Tree set_insert(Tree t, const T& a, bool multi = true) {
if (!multi and count(t, a)) return t;
return insert(t, lower_bound(t, a), a);
}
Tree set_erase(Tree t, const T& a) {
assert(count(t, a));
return erase(t, lower_bound(t, a));
}
}
namespace PRBST = PersistentRandomizedBinarySearchTree;
int main() {
cin.tie(nullptr); ios::sync_with_stdio(false);
int n; cin >> n;
V<> a(n); for (auto&& e : a) cin >> e;
V<> b(n); for (auto&& e : b) cin >> e;
auto ta = PRBST::build(begin(a), end(a));
auto tb = PRBST::build(begin(b), end(b));
int q; cin >> q;
while (q--) {
int x, y, z; cin >> x >> y >> z, --y;
if (x == 1) {
ta = PRBST::set(ta, y, z);
} else if (x == 2) {
tb = PRBST::set(tb, y, z);
} else if (x == 3) {
cout << acc(ta, y, z) << '\n';
} else if (x == 4) {
cout << acc(tb, y, z) << '\n';
} else if (x == 5) {
ta = tb;
} else {
tb = ta;
}
}
}
|
#define NDEBUG 1
#include<bits/stdc++.h>
using namespace std;
using Int = long long;
template <typename T,typename E,typename F,typename G,typename H>
struct SegmentTree{
//using F = function<T(T,T)>;
//using G = function<T(T,E)>;
//using H = function<E(E,E)>;
int n,height;
F f;
G g;
H h;
T ti;
E ei;
vector<T> dat;
vector<E> laz;
SegmentTree(int n_,F f,G g,H h,T ti,E ei):
f(f),g(g),h(h),ti(ti),ei(ei){init(n_);}
void init(int n_){
n=1;height=0;
while(n<n_) n<<=1,height++;
dat.assign(2*n,ti);
laz.assign(2*n,ei);
}
void build(int n_, vector<T> v){
for(int i=0;i<n_;i++) dat[n+i]=v[i];
for(int i=n-1;i;i--)
dat[i]=f(dat[(i<<1)|0],dat[(i<<1)|1]);
}
T reflect(int k){
return g(dat[k],laz[k]);
}
inline void eval(int k){
if(laz[k]==ei) return;
laz[(k<<1)|0]=h(laz[(k<<1)|0],laz[k]);
laz[(k<<1)|1]=h(laz[(k<<1)|1],laz[k]);
dat[k]=reflect(k);
laz[k]=ei;
}
void update(int a,int b,E x){
a+=n;b+=n-1;
for(int i=height;i;i--) eval(a>>i);
for(int i=height;i;i--) eval(b>>i);
for(int l=a,r=b+1;l<r;l>>=1,r>>=1){
if(l&1) laz[l]=h(laz[l],x),l++;
if(r&1) --r,laz[r]=h(laz[r],x);
}
while(a>>=1)
dat[a]=f(reflect((a<<1)|0),reflect((a<<1)|1));
while(b>>=1)
dat[b]=f(reflect((b<<1)|0),reflect((b<<1)|1));
}
T query(int a,int b){
a+=n;b+=n-1;
for(int i=height;i;i--) eval(a>>i);
for(int i=height;i;i--) eval(b>>i);
T vl=ti,vr=ti;
for(int l=a,r=b+1;l<r;l>>=1,r>>=1) {
if(l&1) vl=f(vl,reflect(l++));
if(r&1) vr=f(reflect(--r),vr);
}
return f(vl,vr);
}
void update(int k,T x){
dat[k+=n]=x;
laz[k]=ei;
while(k>>=1)
dat[k]=f(reflect((k<<1)|0),reflect((k<<1)|1));
}
};
//INSERT ABOVE HERE
signed main(){
int n;
scanf("%d",&n);
using P = pair<int,int>;
vector<P> v(n);
for(int i=0;i<n;i++) scanf("%d",&v[i].first);
for(int i=0;i<n;i++) scanf("%d",&v[i].second);
auto f=[](P a,P b){
return P(min(a.first,b.first),
min(a.second,b.second));
};
auto g=[](P a,P b){
if(b.first<0){
if(b.second<0) return a;
return P(a.second,a.second);
}
if(b.second<0)
return P(a.first,a.first);
if(b.second<b.first)
return P(a.second,a.second);
return P(a.first,a.first);
};
auto h=[](P a,P b){
int x=a.first,y=a.second;
if(x<0) x=b.first;
if(y<0) y=b.second;
return P(x,y);
};
SegmentTree<P, P, decltype(f), decltype(g), decltype(h)> rmq(n,f,g,h,P(INT_MAX,INT_MAX),P(-1,-1));
rmq.build(n,v);
int q;
scanf("%d",&q);
for(int i=0;i<q;i++){
int x,y,z;
scanf("%d %d %d",&x,&y,&z);
y--;
if(x==1){
assert(0<=y&&y<n);
P c=rmq.query(y,y+1);
c.first=z;
rmq.update(y,c);
}
if(x==2){
assert(0<=y&&y<n);
P c=rmq.query(y,y+1);
c.second=z;
rmq.update(y,c);
}
if(x==3){
assert(0<=y&&y<z);
P c=rmq.query(y,z);
printf("%d\n",c.first);
}
if(x==4){
assert(0<=y&&y<z);
P c=rmq.query(y,z);
printf("%d\n",c.second);
}
if(x==5){
rmq.query(0,n);
rmq.update(0,n,P(-1,i));
}
if(x==6){
rmq.query(0,n);
rmq.update(0,n,P(i,-1));
}
}
return 0;
}
|
#include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<iomanip>
#include<math.h>
#include<complex>
#include<queue>
#include<deque>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<functional>
#include<assert.h>
#include<numeric>
using namespace std;
#define REP(i,m,n) for(int i=(int)(m) ; i < (int) (n) ; ++i )
#define rep(i,n) REP(i,0,n)
using ll = long long;
const int inf=1e9+7;
const ll longinf=1LL<<60 ;
const ll mod=1e9+7 ;
struct Node{
int val;
Node* lhs, *rhs;
Node(int val):val(val),lhs(nullptr),rhs(nullptr){}
};
Node* update(Node* t,int l, int r,int k,int x){
if(k<l||r<=k)return t;
if(l+1==r){
Node* ret = new Node(x);
return ret;
}
int mid=(l+r)/2;
Node* ret = new Node(inf);
ret->lhs = update(t->lhs,l,mid,k,x);
ret->rhs = update(t->rhs,mid,r,k,x);
ret->val = min(ret->lhs->val, ret->rhs->val);
return ret;
}
int query(Node* t,int a,int b, int l, int r){
if(b<=l||r<=a)return inf;
if(a<=l&&r<=b)return t->val;
int vl = query(t->lhs, a,b,l,(l+r)/2);
int vr = query(t->rhs, a,b,(l+r)/2, r);
return min(vl,vr);
}
Node* build(vector<int>& v, int l, int r){
Node* ret = new Node(inf);
if(l+1==r){
ret->val=v[l];
return ret;
}
ret->lhs = build(v,l,(l+r)/2);
ret->rhs = build(v,(l+r)/2,r);
ret->val = min(ret->lhs->val, ret->rhs->val);
return ret;
}
int main(){
int n;
cin>>n;
int m=1;
while(m<n)m*=2;
vector<int> a(m,inf), b(m,inf);
rep(i,n)cin>>a[i];
rep(i,n)cin>>b[i];
Node* A = build(a,0,m);
Node* B = build(b,0,m);
int q;
cin>>q;
while(q--){
int x,y,z;
scanf("%d%d%d",&x,&y,&z);
--y;
if(x==1){
A = update(A, 0, m, y, z);
}
if(x==2){
B = update(B, 0, m, y, z);
}
if(x==5){
A = B;
}
if(x==6){
B = A;
}
if(x==3){
printf("%d\n",query(A,y,z,0,m));
}
if(x==4){
printf("%d\n",query(B,y,z,0,m));
}
}
return 0;
}
|
#include <bits/stdc++.h>
#define REP(i, a, n) for(ll i = ((ll) a); i < ((ll) n); i++)
#define INF (1LL << 60)
using namespace std;
typedef long long ll;
ll N, A, B, Q, X, Y, Z;
template<typename T> class SegmentTree {
public:
ll n;
T e;
T (*op)(T, T);
vector<T> dat;
SegmentTree(T _e, T(*_op)(T, T), ll _n) {
e = _e;
op = _op;
n = 1;
while(n < _n) n *= 2;
REP(i, 0, 2 * n - 1) dat.push_back(e);
}
T query(ll a, ll b) { return rquery(a, b, 0, 0, n); };
void update(ll k, T a) {
k += n - 1;
dat[k] = a;
while(k > 0) {
k = (k - 1) / 2;
dat[k] = op(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
private:
T rquery(ll a, ll b, ll k, ll l, ll r) {
if(r <= a || b <= l) return e;
if(a <= l && r <= b) return dat[k];
T vl = rquery(a, b, k * 2 + 1, l, (l + r) / 2);
T vr = rquery(a, b, k * 2 + 2, (l + r) / 2, r);
return op(vl, vr);
}
};
ll opmin(ll a, ll b) { return min(a, b); };
int main(void) {
SegmentTree<ll> sa(INF, opmin, 200000), sb(INF, opmin, 200000);
cin >> N;
REP(i, 0, N) {
cin >> A;
sa.update(i, A);
// cout << A << endl;
}
REP(i, 0, N) {
cin >> B;
sb.update(i, B);
// cout << B << endl;
}
cin >> Q;
// REP(i, 0, N) cout << sa.dat[i] << " ";
// cout << endl;
// REP(i, 0, N) cout << sb.dat[i] << " ";
// cout << endl;
vector<ll> u;
REP(i, 0, N) u.push_back(i);
// REP(j, 0, N) cout << sa.query(j, j + 1) << " ";
// cout << endl;
// REP(j, 0, N) cout << sb.query(j, j + 1) << " ";
// cout << endl;
REP(q, 0, Q) {
cin >> X >> Y >> Z;
// cout << " " << X << " " << Y << " " << Z << endl;
if(X == 1) { // update A[Y] = Z
sa.update(Y - 1, Z);
u.push_back(Y - 1);
}
if(X == 2) { // update B[Y] = Z
sb.update(Y - 1, Z);
u.push_back(Y - 1);
}
if(X == 3) { // max(A[Y], ..., A[Z])
cout << sa.query(Y - 1, Z) << endl;;
}
if(X == 4) { // max(B[Y], ..., B[Z])
cout << sb.query(Y - 1, Z) << endl;
}
if(X == 5) { // copy A <- B
REP(i, 0, u.size()) sa.update(u[i], sb.dat[u[i] + sb.n - 1]);
u.clear();
}
if(X == 6) { // copy B <- A
REP(i, 0, u.size()) sb.update(u[i], sa.dat[u[i] + sa.n - 1]);
u.clear();
}
// REP(j, 0, N) cout << sa.query(j, j + 1) << " ";
// cout << endl;
// REP(j, 0, N) cout << sb.query(j, j + 1) << " ";
// cout << endl;
}
} |
#include <algorithm>
#include <iostream>
#include <vector>
#include <functional>
using namespace std;
template<typename Monoid>
struct SegmentTree {
using F = function<Monoid(Monoid, Monoid)>;
const F f;
const Monoid M1;
int sz;
vector<Monoid> dat;
SegmentTree(int n, const F f, const Monoid &M1) : f(f), M1(M1), sz(1) {
while (sz < n) sz <<= 1;
dat.assign(sz * 2, M1);
}
void set(int k, const Monoid &x) { dat[k + sz] = x; }
void build() {
for (int k = sz - 1; k > 0; k--) {
dat[k] = f(dat[2 * k], dat[2 * k + 1]);
}
}
void update(int k, const Monoid &x) {
dat[k += sz] = x;
while (k >>= 1) dat[k] = f(dat[2 * k], dat[2 * k + 1]);
}
Monoid get(int a, int b) { // [a, b)
Monoid L = M1, R = M1;
for (a += sz, b += sz; a < b; a >>= 1, b >>= 1) {
if (a & 1) L = f(L, dat[a++]);
if (b & 1) R = f(dat[--b], R);
}
return f(L, R);
}
Monoid operator[](const int &k) const { return dat[k + sz]; }
friend ostream& operator<<(ostream& os, SegmentTree<Monoid> &seg) {
for (int i = 0; i < seg.sz; i++) os << seg[i] << " ";
return os;
}
};
const int INF = numeric_limits<int>::max();
int main() {
int n; cin >> n;
SegmentTree<int> seg1(n, [](int a, int b) { return min(a, b); }, INF);
SegmentTree<int> seg2(n, [](int a, int b) { return min(a, b); }, INF);
for (int i = 0; i < n; i++) { int a; cin >> a; seg1.set(i, a); }
for (int i = 0; i < n; i++) { int b; cin >> b; seg2.set(i, b); }
seg1.build();
seg2.build();
int q; cin >> q;
vector<pair<int, int>> a_his, a_upd, b_his, b_upd;
bool init = true;
#define eb emplace_back
while (q--) {
int x, y, z; cin >> x >> y >> z; y--;
if (x == 1) a_his.eb(y, seg1[y]), seg1.update(y, z), a_upd.eb(y, z);
if (x == 2) b_his.eb(y, seg2[y]), seg2.update(y, z), b_upd.eb(y, z);
if (x == 3) cout << seg1.get(y, z) << endl;
if (x == 4) cout << seg2.get(y, z) << endl;
if (x == 5) {
if (init) {
for (int i = 0; i < n; i++) seg1.update(i, seg2[i]);
init = false;
} else {
reverse(a_his.begin(), a_his.end());
for (auto &p: a_his) seg1.update(p.first, p.second);
for (auto &p: b_upd) seg1.update(p.first, p.second);
}
a_his.clear(), a_upd.clear(), b_his.clear(), b_upd.clear();
}
if (x == 6) {
if (init) {
for (int i = 0; i < n; i++) seg2.update(i, seg1[i]);
init = false;
} else {
reverse(b_his.begin(), b_his.end());
for (auto &p: b_his) seg2.update(p.first, p.second);
for (auto &p: a_upd) seg2.update(p.first, p.second);
}
a_his.clear(), a_upd.clear(), b_his.clear(), b_upd.clear();
}
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
template <typename T,typename E>
struct SegmentTree{
typedef function<T(T,T)> F;
typedef function<T(T,E)> G;
typedef function<E(E,E)> H;
typedef function<E(E,int)> P;
int n;
F f;
G g;
H h;
P p;
T d1;
E d0;
vector<T> dat;
vector<E> laz;
SegmentTree(int n_,F f,G g,H h,P p,T d1,E d0){
this->f=f;
this->g=g;
this->h=h;
this->p=p;
this->d1=d1;
this->d0=d0;
init(n_);
}
SegmentTree(int n_,F f,G g,H h,P p,T d1,E d0,vector<T> v){
this->f=f;
this->g=g;
this->h=h;
this->p=p;
this->d1=d1;
this->d0=d0;
init(n_);
build(n_,v);
}
void init(int n_){
n=1;
while(n<n_) n*=2;
dat.clear();
dat.resize(2*n-1,d1);
laz.clear();
laz.resize(2*n-1,d0);
}
void build(int n_, vector<T> v){
for(int i=0;i<n_;i++) dat[i+n-1]=v[i];
for(int i=n-2;i>=0;i--)
dat[i]=f(dat[i*2+1],dat[i*2+2]);
}
inline void eval(int len,int k){
if(k*2+1<n*2-1){
laz[k*2+1]=h(laz[k*2+1],laz[k]);
laz[k*2+2]=h(laz[k*2+2],laz[k]);
}
dat[k]=g(dat[k],p(laz[k],len));
laz[k]=d0;
}
T update(int a,int b,E x,int k,int l,int r){
eval(r-l,k);
if(r<=a||b<=l) return g(dat[k],p(laz[k],r-l));
if(a<=l&&r<=b){
laz[k]=h(laz[k],x);
return g(dat[k],p(laz[k],r-l));
}
return dat[k]=f(update(a,b,x,k*2+1,l,(l+r)/2),
update(a,b,x,k*2+2,(l+r)/2,r));
}
T update(int a,int b,E x){
return update(a,b,x,0,0,n);
}
T query(int a,int b,int k,int l,int r){
eval(r-l,k);
if(r<=a||b<=l) return d1;
if(a<=l&&r<=b) return dat[k];
T vl=query(a,b,k*2+1,l,(l+r)/2);
T vr=query(a,b,k*2+2,(l+r)/2,r);
return f(vl,vr);
}
T query(int a,int b){
return query(a,b,0,0,n);
}
void update(int k,T x){
k+=n-1;
dat[k]=x;
while(k){
k=(k-1)/2;
dat[k]=f(dat[k*2+1],dat[k*2+2]);
}
}
};
signed main(){
int n;
scanf("%d",&n);
typedef pair<int,int> P;
vector<P> v(n);
for(int i=0;i<n;i++) scanf("%d",&v[i].first);
for(int i=0;i<n;i++) scanf("%d",&v[i].second);
SegmentTree<P,P> rmq(n,
[](P a,P b){
return P(min(a.first,b.first),
min(a.second,b.second));
},
[](P a,P b){
if(b.first<0){
if(b.second<0) return a;
return P(a.second,a.second);
}
if(b.second<0)
return P(a.first,a.first);
if(b.second<b.first)
return P(a.second,a.second);
return P(a.first,a.first);
},
[](P a,P b){
int x=a.first,y=a.second;
if(x<0) x=b.first;
if(y<0) y=b.second;
return P(x,y);
},
[](P a,int k){
return a;
},
P(INT_MAX,INT_MAX),P(-1,-1),v);
int q;
scanf("%d",&q);
for(int i=0;i<q;i++){
int x,y,z;
scanf("%d %d %d",&x,&y,&z);
y--;
if(x==1){
assert(0<=y&&y<n);
P c=rmq.query(y,y+1);
c.first=z;
rmq.update(y,c);
}
if(x==2){
assert(0<=y&&y<n);
P c=rmq.query(y,y+1);
c.second=z;
rmq.update(y,c);
}
if(x==3){
assert(0<=y&&y<z);
P c=rmq.query(y,z);
printf("%d\n",c.first);
}
if(x==4){
assert(0<=y&&y<z);
P c=rmq.query(y,z);
printf("%d\n",c.second);
}
if(x==5){
rmq.query(0,rmq.n);
rmq.update(0,rmq.n,P(-1,i));
}
if(x==6){
rmq.query(0,rmq.n);
rmq.update(0,rmq.n,P(i,-1));
}
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
using Int = long long;
//BEGIN CUT HERE
template <typename T>
struct SegmentTree{
using F = function<T(T,T)>;
F f;
T ti;
SegmentTree(F f,T ti):f(f),ti(ti){}
struct Node{
Node *l,*r;
T dat;
Node(T dat):dat(dat){l=r=nullptr;}
};
Node* clone(Node *a){
return new Node(*a);
}
Node* reflect(Node *a){
a->dat=f(a->l->dat,a->r->dat);
return a;
}
int n,height;
Node* build(const vector<T> &v){
int n_=v.size();
n=1;height=0;
while(n<n_) n<<=1,height++;
vector<Node*> vs(n<<1);
for(int i=0;i<n_;i++) vs[n+i]=new Node(v[i]);
for(int i=n_;i<n;i++) vs[n+i]=new Node(ti);
for(int i=n-1;i;i--){
vs[i]=new Node(ti);
vs[i]->l=vs[(i<<1)|0];
vs[i]->r=vs[(i<<1)|1];
reflect(vs[i]);
}
return vs[1];
}
Node* set_val(Node* t,int k,T x,int h){
t=clone(t);
if(h<0){
t->dat=x;
return t;
}
if((k>>h)&1) t->r=set_val(t->r,k,x,h-1);
else t->l=set_val(t->l,k,x,h-1);
return reflect(t);
}
T query(Node* t,int l,int r,int lb,int ub){
if(r<=lb||ub<=l) return ti;
if(l<=lb&&ub<=r) return t->dat;
int m=(lb+ub)>>1;
return f(query(t->l,l,r,lb,m),query(t->r,l,r,m,ub));
}
Node* set_val(Node* t,int k,T x){
return set_val(t,k,x,height-1);
}
T query(Node* t,int l,int r){
return query(t,l,r,0,n);
}
};
//END CUT HERE
//INSERT ABOVE HERE
signed HAPPYQUERY_B(){
cin.tie(0);
ios::sync_with_stdio(0);
int n;
cin>>n;
vector<int> as(n);
for(int i=0;i<n;i++) cin>>as[i];
auto f=[](int a,int b){return min(a,b);};
int ti=INT_MAX;
SegmentTree<int> seg(f,ti);
auto rt=seg.build(as);
vector<decltype(rt)> rts;
rts.emplace_back(rt);
int q1;
cin>>q1;
rts.reserve(q1+1);
for(int i=0;i<q1;i++){
int p,x;
cin>>p>>x;
p--;
rt=seg.set_val(rt,p,x);
rts.emplace_back(rt);
}
int q2;
cin>>q2;
int x=0;
for(int i=0;i<q2;i++){
int a,b,c;
cin>>a>>b>>c;
int k=a^x;
int l=(b^x)-1;
int r=(c^x);
assert(l<r);
x=seg.query(rts[k],l,r);
cout<<x<<"\n";
}
cout<<flush;
return 0;
}
/*
verified on 2019/06/22
https://www.hackerrank.com/contests/happy-query-contest/challenges/minimum-history-query
*/
signed AOJ_3024(){
cin.tie(0);
ios::sync_with_stdio(0);
int n;
cin>>n;
vector<int> as(n),bs(n);
for(int i=0;i<n;i++) cin>>as[i];
for(int i=0;i<n;i++) cin>>bs[i];
auto f=[](int a,int b){return min(a,b);};
int ti=INT_MAX;
SegmentTree<int> seg(f,ti);
auto ra=seg.build(as);
auto rb=seg.build(bs);
int q;
cin>>q;
for(int i=0;i<q;i++){
int x,y,z;
cin>>x>>y>>z;
y--;
if(x==1) ra=seg.set_val(ra,y,z);
if(x==2) rb=seg.set_val(rb,y,z);
if(x==3) cout<<seg.query(ra,y,z)<<"\n";
if(x==4) cout<<seg.query(rb,y,z)<<"\n";
if(x==5) ra=seg.clone(rb);
if(x==6) rb=seg.clone(ra);
}
cout<<flush;
return 0;
}
signed main(){
//HAPPYQUERY_B();
AOJ_3024();
return 0;
}
|
#include <bits/stdc++.h>
#define MOD 1000000007LL
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
int n_=1<<19;
class segtree{
public:
int dp[1<<20];
segtree(){
memset(dp,0,sizeof(dp));
}
void update(int k,int v){
k+=n_-1;
dp[k]=v;
while(k>0){
k=(k-1)/2;
dp[k]=min(dp[k*2+1],dp[k*2+2]);
}
}
int query(int a,int b,int k=0,int l=0,int r=n_){
if(b<=l || r<=a)return 2e9;
if(a<=l && r<=b)return dp[k];
int mid=(l+r)/2;
int vl=query(a,b,k*2+1,l,mid);
int vr=query(a,b,k*2+2,mid,r);
return min(vl,vr);
}
};
segtree seg[2];
int n,q;
int a[200005],b[200005];
set<int> s;
int main(void){
scanf("%d",&n);
for(int i=0;i<n;i++){
scanf("%d",&a[i]);
seg[0].update(i,a[i]);
}
for(int i=0;i<n;i++){
scanf("%d",&b[i]);
seg[1].update(i,b[i]);
}
scanf("%d",&q);
bool flag=false;
for(int i=0;i<q;i++){
int x,y,z;
scanf("%d%d%d",&x,&y,&z);
y--;
if(x==1){
s.insert(y);
seg[0].update(y,z);
}
if(x==2){
s.insert(y);
seg[1].update(y,z);
}
if(x==3){
printf("%d\n",seg[0].query(y,z));
}
if(x==4){
printf("%d\n",seg[1].query(y,z));
}
if(x==5 || x==6){
int side=x-5;
if(!flag){
for(int i=0;i<n;i++){
seg[side].update(i,seg[1-side].query(i,i+1));
}
flag=true;
}else{
for(set<int>::iterator it=s.begin();it!=s.end();it++){
seg[side].update(*it,seg[1-side].query(*it,(*it)+1));
}
}
s.clear();
}
}
return 0;
} |
#include <cstdio>
#include <algorithm>
const int S = 2e5 * 30, inf = 2e9;
int ls[S], rs[S], mx[S], sz;
int build(int l, int r) {
int o = sz++;
ls[o] = rs[o] = 0;
if (l + 1 == r) {
scanf("%d", &mx[o]);
return o;
}
int m = (l + r) >> 1;
ls[o] = build(l, m);
rs[o] = build(m, r);
mx[o] = std::min(mx[ls[o]], mx[rs[o]]);
return o;
}
int ins(int o, int l, int r, int x, int v) {
int p = sz++;
ls[p] = ls[o];
rs[p] = rs[o];
if (l + 1 == r) {
mx[p] = v;
return p;
}
int m = (l + r) >> 1;
if (x < m) ls[p] = ins(ls[o], l, m, x, v);
else rs[p] = ins(rs[o], m, r, x, v);
mx[p] = std::min(mx[ls[p]], mx[rs[p]]);
return p;
}
int ask(int o, int l, int r, int L, int R) {
if (L <= l && R >= r) return mx[o];
int ret = inf, m = (l + r) >> 1;
if (L < m) ret = std::min(ret, ask(ls[o], l, m, L, R));
if (R > m) ret = std::min(ret, ask(rs[o], m, r, L, R));
return ret;
}
int main() {
ls[0] = rs[0] = 0;
mx[0] = inf;
sz = 1;
int n;
scanf("%d", &n);
int ra = build(0, n);
int rb = build(0, n);
int q;
scanf("%d", &q);
while (q--) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
if (x == 1) ra = ins(ra, 0, n, y - 1, z);
if (x == 2) rb = ins(rb, 0, n, y - 1, z);
if (x == 3) printf("%d\n", ask(ra, 0, n, y - 1, z));
if (x == 4) printf("%d\n", ask(rb, 0, n, y - 1, z));
if (x == 5) ra = rb;
if (x == 6) rb = ra;
}
return 0;
} |
#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<b;i++)
#define rrep(i,a,b) for(int i=a;i>=b;i--)
#define fore(i,a) for(auto &i:a)
#pragma GCC optimize ("-O3")
using namespace std; void _main(); int main() { cin.tie(0); ios::sync_with_stdio(false); _main(); }
//---------------------------------------------------------------------------------------------------
/*---------------------------------------------------------------------------------------------------
????????????????????????????????? ??§?????§
??????????????? ??§?????§ ???????´<_??? ?????? Welcome to My Coding Space!
???????????? ??? ?´_???`??????/??? ???i
?????????????????????????????? ??? |???|
????????? /?????? /??£??£??£??£/??????|
??? ???_(__??????/??? ???/ .| .|????????????
??? ????????????/????????????/??????u??????
---------------------------------------------------------------------------------------------------*/
int N, A[201010], B[201010], Q;
//--------------------------------------------------------------------------------------------------
#define INF INT_MAX/2
int S, Ami[1010], Bmi[1010];
int AorB[1010]; // -1:none 0:A 1:B
void update(int s) {
int L = s * S, R = (s + 1) * S;
Ami[s] = Bmi[s] = INF;
rep(i, L, R) if (i < N) {
Ami[s] = min(Ami[s], A[i]);
Bmi[s] = min(Bmi[s], B[i]);
}
}
void lazy(int s) {
int L = s * S, R = (s + 1) * S;
if (AorB[s] == 0) {
rep(i, L, R) if (i < N) B[i] = A[i];
AorB[s] = -1;
}
if(AorB[s] == 1) {
rep(i, L, R) if (i < N) A[i] = B[i];
AorB[s] = -1;
}
}
void init() {
S = sqrt(N);
rep(i, 0, N / S + 1) update(i);
rep(i, 0, N / S + 1) AorB[i] = -1;
}
//--------------------------------------------------------------------------------------------------
void _main() {
cin >> N;
rep(i, 0, N) cin >> A[i];
rep(i, 0, N) cin >> B[i];
init();
cin >> Q;
rep(i, 0, Q) {
int x, y, z; cin >> x >> y >> z;
if (x == 1) {
y--;
int s = y / S;
lazy(s);
A[y] = z;
update(s);
}
if (x == 2) {
y--;
int s = y / S;
lazy(s);
B[y] = z;
update(s);
}
if (x == 3) {
y--;
int ans = INF;
rep(i, 0, N / S + 1) {
int a = i * S, b = (i + 1) * S;
if (y <= a && b <= z) {
if (AorB[i] == 1) ans = min(ans, Bmi[i]);
else ans = min(ans, Ami[i]);
}
else {
if (max(a, y) < min(b, z)) {
lazy(i);
update(i);
rep(j, max(a, y), min(b, z)) ans = min(ans, A[j]);
}
}
}
printf("%d\n", ans);
}
if (x == 4) {
y--;
int ans = INF;
rep(i, 0, N / S + 1) {
int a = i * S, b = (i + 1) * S;
if (y <= a && b <= z) {
if (AorB[i] == 0) ans = min(ans, Ami[i]);
else ans = min(ans, Bmi[i]);
}
else {
if (max(a, y) < min(b, z)) {
lazy(i);
update(i);
rep(j, max(a, y), min(b, z)) ans = min(ans, B[j]);
}
}
}
printf("%d\n", ans);
}
if (x == 5) {
rep(i, 0, N / S + 1) if (AorB[i] != 0) AorB[i] = 1;
}
if (x == 6) {
rep(i, 0, N / S + 1) if (AorB[i] != 1) AorB[i] = 0;
}
}
} |
#include <iostream>
#include <vector>
#include <array>
#include <string>
#include <stack>
#include <queue>
#include <deque>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <tuple>
#include <bitset>
#include <memory>
#include <cmath>
#include <algorithm>
#include <functional>
#include <iomanip>
#include <numeric>
#include <climits>
#include <cfloat>
class PersistentMinSegTree;
class MinSegBranch;
using seg = std::shared_ptr<PersistentMinSegTree>;
class PersistentMinSegTree {
public:
virtual bool is_defined_at(const int position) const = 0;
virtual int min_of_all() const = 0;
virtual int min_of(const int from, const int to) const = 0;
virtual seg updated(const int position, const int new_value) = 0;
};
class MinSegBranch : public PersistentMinSegTree {
seg left, right;
int from, to, min_cache;
public:
MinSegBranch(int _from, int _to, const seg& _left, const seg& _right) : left{ _left }, right{ _right }, from{ _from }, to{ _to }, min_cache{ std::min(_left->min_of_all(), _right->min_of_all()) }{};
bool is_defined_at(const int position) const override { return from <= position && position <= to; }
int min_of_all() const override { return min_cache; }
int min_of(const int from, const int to) const override {
if (from <= this->from && this->to <= to) {
return min_cache;
}
else if (this->from <= to && from <= this->to) {
return std::min(left->min_of(from, to), right->min_of(from, to));
}
else {
return INT_MAX;
}
}
seg updated(const int position, const int new_value) override {
if (left->is_defined_at(position)) return std::make_shared<MinSegBranch>(from, to, left->updated(position, new_value), right);
if (right->is_defined_at(position)) return std::make_shared<MinSegBranch>(from, to, left, right->updated(position, new_value));
throw 0;
}
};
class MinSegLeaf : public PersistentMinSegTree {
int position, value;
public:
MinSegLeaf(const int _position, const int _value) : position{ _position }, value{ _value }{};
bool is_defined_at(const int position) const override { return position == this->position; }
int min_of_all() const override { return value; }
int min_of(const int from, const int to) const override { return (from <= position && position <= to) ? value : INT_MAX; }
seg updated(const int position, const int new_value) override {
return (position == this->position) ? std::make_shared<MinSegLeaf>(position, new_value) : throw 0;
}
};
class MinSegmentTree {
seg root;
static seg make(const std::vector<int>& array, const int from, const int until) {
return (until - from == 1) ? std::shared_ptr<PersistentMinSegTree>(new MinSegLeaf(from, array[from])) : std::make_shared<MinSegBranch>(from, until - 1, make(array, from, (from + until) / 2), make(array, (from + until) / 2, until));
}
MinSegmentTree(seg _root) :root{ _root } {};
public:
void copy_from(const MinSegmentTree& tree) {
root = tree.root;
}
static MinSegmentTree make(const std::vector<int>& array) {
return MinSegmentTree(make(array, 0, array.size()));
}
void update(int position, int new_value) {
root = root->updated(position, new_value);
}
int min_of(int from, int to) const {
return root->min_of(from, to);
}
};
int main() {
std::cin.tie(0); std::cin.sync_with_stdio(false);
int n; std::cin >> n;
std::vector<int> a(n), b(n); for (auto& i : a) std::cin >> i; for (auto& i : b) std::cin >> i;
auto seg_a = MinSegmentTree::make(a);
auto seg_b = MinSegmentTree::make(b);
int q; std::cin >> q;
for (auto _i = 0; _i < q; ++_i) {
int x, y, z; std::cin >> x >> y >> z;
switch (x) {
case 1: seg_a.update(y - 1, z); break;
case 2: seg_b.update(y - 1, z); break;
case 3: std::cout << seg_a.min_of(y - 1, z - 1) << '\n'; break;
case 4: std::cout << seg_b.min_of(y - 1, z - 1) << '\n'; break;
case 5: seg_a.copy_from(seg_b); break;
case 6: seg_b.copy_from(seg_a); break;
default: throw 0;
}
}
}
|
#include <bits/stdc++.h>
#define REP(i, a, n) for(ll i = ((ll) a); i < ((ll) n); i++)
#define INF (1LL << 60)
using namespace std;
typedef long long ll;
ll N, A, B, Q, X, Y, Z;
template<typename T> class SegmentTree {
public:
ll n;
T e;
T (*op)(T, T);
vector<T> dat;
SegmentTree(T _e, T(*_op)(T, T), ll _n) {
e = _e;
op = _op;
n = 1;
while(n < _n) n *= 2;
REP(i, 0, 2 * n - 1) dat.push_back(e);
}
T query(ll a, ll b) { return rquery(a, b, 0, 0, n); };
void update(ll k, T a) {
k += n - 1;
dat[k] = a;
while(k > 0) {
k = (k - 1) / 2;
dat[k] = op(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
private:
T rquery(ll a, ll b, ll k, ll l, ll r) {
if(r <= a || b <= l) return e;
if(a <= l && r <= b) return dat[k];
T vl = rquery(a, b, k * 2 + 1, l, (l + r) / 2);
T vr = rquery(a, b, k * 2 + 2, (l + r) / 2, r);
return op(vl, vr);
}
};
ll opmin(ll a, ll b) { return min(a, b); };
int main(void) {
SegmentTree<ll> sa(INF, opmin, 200000), sb(INF, opmin, 200000);
cin >> N;
REP(i, 0, N) {
cin >> A;
sa.update(i, A);
}
REP(i, 0, N) {
cin >> B;
sb.update(i, B);
}
cin >> Q;
vector<ll> u;
REP(i, 0, N) u.push_back(i);
REP(q, 0, Q) {
cin >> X >> Y >> Z;
if(X == 1) { // update A[Y] = Z
sa.update(Y - 1, Z);
u.push_back(Y - 1);
}
if(X == 2) { // update B[Y] = Z
sb.update(Y - 1, Z);
u.push_back(Y - 1);
}
if(X == 3) { // max(A[Y], ..., A[Z])
cout << sa.query(Y - 1, Z) << endl;;
}
if(X == 4) { // max(B[Y], ..., B[Z])
cout << sb.query(Y - 1, Z) << endl;
}
if(X == 5) { // copy A <- B
REP(i, 0, u.size()) sa.update(u[i], sb.dat[u[i] + sb.n - 1]);
u.clear();
}
if(X == 6) { // copy B <- A
REP(i, 0, u.size()) sb.update(u[i], sa.dat[u[i] + sa.n - 1]);
u.clear();
}
}
} |
#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
#define rep(i,s,e) for(int (i) = (s);(i) <= (e);(i)++)
#define all(x) x.begin(),x.end()
vector<i64> A(202020,1e18),B(202020,1e18);
vector<i64> Ab(512,1e18),Bb(512,1e18);
vector<int> lazy(512,0);
const int Interval = 512;
int N;
const i64 INF = 1e18;
void LAZY(int s){
if(lazy[s] == 0) return;
if(lazy[s] == 1){Ab[s] = Bb[s];}
if(lazy[s] == -1){Bb[s] = Ab[s];}
for(int i = s * Interval;i < (s + 1) * Interval;i++){
if(lazy[s] == 1){A[i] = B[i];}
if(lazy[s] == -1){B[i] = A[i];}
}
lazy[s] = 0;
}
int main(){
cin >> N;
rep(i,0,N - 1) cin >> A[i];
rep(i,0,N - 1) cin >> B[i];
rep(i,0,N - 1) Ab[i/ Interval] = min(Ab[i / Interval] , A[i]);
rep(i,0,N - 1) Bb[i/ Interval] = min(Bb[i / Interval] , B[i]);
int Q;
cin >> Q;
rep(q,0,Q - 1){
int x,y,z;
cin >> x >> y >> z;
if(x == 1){
y--;
LAZY(y / Interval);
A[y] = z;
int start = y - y % Interval;
int end = start + Interval;
end = min(end,N);
Ab[y / Interval] = INF;
for(int i = start;i < end;i++){
Ab[y / Interval] = min(Ab[y / Interval],A[i]);
}
Bb[y / Interval] = INF;
for(int i = start;i < end;i++){
Bb[y / Interval] = min(Bb[y / Interval],B[i]);
}
}
if(x == 2){
y--;
LAZY(y / Interval);
B[y] = z;
int start = y - y % Interval;
int end = start + Interval;
end = min(end,N);
Ab[y / Interval] = INF;
for(int i = start;i < end;i++){
Ab[y / Interval] = min(Ab[y / Interval],A[i]);
}
Bb[y / Interval] = INF;
for(int i = start;i < end;i++){
Bb[y / Interval] = min(Bb[y / Interval],B[i]);
}
}
if(x == 3){
y--;
i64 ans = A[y];
int before = -1;
while(y < z){
if(y % Interval == 0 && y + Interval <= z){
if(lazy[y / Interval] != 1) ans = min(ans , Ab[y / Interval]);
else ans = min(ans , Bb[y / Interval]);
y += Interval;
}
else{
LAZY(y / Interval);
if(before != y / Interval){
int start = y - y % Interval;
int end = start + Interval;
end = min(end,N);
Ab[y / Interval] = INF;
for(int i = start;i < end;i++){
Ab[y / Interval] = min(Ab[y / Interval],A[i]);
}
Bb[y / Interval] = INF;
for(int i = start;i < end;i++){
Bb[y / Interval] = min(Bb[y / Interval],B[i]);
}
}
before = y / Interval;
ans = min(ans , A[y]);
y++;
}
}
cout << ans << endl;
}
if(x == 4){
y--;
i64 ans = B[y];
int before = -1;
while(y < z){
if(y % Interval == 0 && y + Interval <= z){
if(lazy[y / Interval] != -1) ans = min(ans , Bb[y / Interval]);
else ans = min(ans , Ab[y / Interval]);
y += Interval;
}
else{
LAZY(y / Interval);
if(before != y / Interval){
int start = y - y % Interval;
int end = start + Interval;
end = min(end,N);
Ab[y / Interval] = INF;
for(int i = start;i < end;i++){
Ab[y / Interval] = min(Ab[y / Interval],A[i]);
}
Bb[y / Interval] = INF;
for(int i = start;i < end;i++){
Bb[y / Interval] = min(Bb[y / Interval],B[i]);
}
}
before = y / Interval;
ans = min(ans , B[y]);
y++;
}
}
cout << ans << endl;
}
if(x == 5){
for(int i = 0;i < N / Interval + 1;i++){
if(lazy[i] != -1) lazy[i] = 1;
}
}
if(x == 6){
for(int i = 0;i < N / Interval + 1;i++){
if(lazy[i] != 1) lazy[i] = -1;
}
}
}
}
|
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i,n) for(int i=0;i<(n);i++)
#define pb push_back
#define all(v) (v).begin(),(v).end()
#define fi first
#define se second
typedef vector<int>vint;
typedef pair<int,int>pint;
typedef vector<pint>vpint;
template<typename A,typename B>inline void chmin(A &a,B b){if(a>b)a=b;}
template<typename A,typename B>inline void chmax(A &a,B b){if(a<b)a=b;}
const int POOL_SIZE=10000000;
struct node{
int v;
node *l,*r;
node(){v=0;l=r=NULL;};
}pool[POOL_SIZE];
int uku=0;
node *aloc(){
assert(uku<POOL_SIZE);
return &pool[uku++];
}
const int SEG=1<<18;
const int INF=1001001001001001001ll;
int N;
int A[SEG*2];
int B[SEG*2];
node *build(int k,int l,int r,int A[]){
if(l+1==r){
node *t=aloc();
t->v=A[l];
return t;
}
node *x=build(k*2+1,l,(l+r)/2,A);
node *y=build(k*2+2,(l+r)/2,r,A);
node *t=aloc();
t->v=min(x->v,y->v);
t->l=x;
t->r=y;
return t;
}
int getmin(int a,int b,node *t,int l=0,int r=SEG){
if(r<=a||b<=l)return INF;
if(a<=l&&r<=b)return t->v;
return min(getmin(a,b,t->l,l,(l+r)/2),getmin(a,b,t->r,(l+r)/2,r));
}
node *update(int p,int v,node *t,int l=0,int r=SEG){
if(!(l<=p&&p<r))return t;
if(l+1==r){
t=aloc();
t->v=v;
return t;
}
node *s=aloc();
s->l=update(p,v,t->l,l,(l+r)/2);
s->r=update(p,v,t->r,(l+r)/2,r);
s->v=min(s->l->v,s->r->v);
return s;
}
signed main(){
fill_n(A,SEG,INF);
fill_n(B,SEG,INF);
scanf("%lld",&N);
rep(i,N){
scanf("%lld",&A[i]);
}
rep(i,N){
scanf("%lld",&B[i]);
}
node *rootA=build(0,0,SEG,A);
node *rootB=build(0,0,SEG,B);
int Q;scanf("%lld",&Q);
while(Q--){
int x,y,z;
scanf("%lld%lld%lld",&x,&y,&z);
y--;
if(x==1){
rootA=update(y,z,rootA);
}
if(x==2){
rootB=update(y,z,rootB);
}
if(x==3){
printf("%lld\n",getmin(y,z,rootA));
}
if(x==4){
printf("%lld\n",getmin(y,z,rootB));
}
if(x==5){
rootA=rootB;
}
if(x==6){
rootB=rootA;
}
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define all(v) (v).begin(), (v).end()
#define resz(v, ...) (v).clear(), (v).resize(__VA_ARGS__)
#define reps(i, m, n) for(int i = (int)(m); i < (int)(n); i++)
#define rep(i, n) reps(i, 0, n)
template<class T1, class T2> void chmin(T1 &a, T2 b){if(a>b)a=b;}
template<class T1, class T2> void chmax(T1 &a, T2 b){if(a<b)a=b;}
using Pi = pair<int, int>;
using Tapris = tuple<int, int, int>;
using vint = vector<int>;
const int inf = 1LL << 55;
const int mod = 1e9 + 7;
signed main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cout << fixed << setprecision(12);
const int sqrtN = 512;
int n;
cin >> n;
vint a(n), b(n);
rep(i, n) cin >> a[i];
rep(i, n) cin >> b[i];
int bucket_sz = (n+sqrtN-1)/sqrtN;
vint bucketFlagA(bucket_sz, 0);
vint bucketFlagB(bucket_sz, 0);
vint bucketMinA(bucket_sz, inf);
vint bucketMinB(bucket_sz, inf);
rep(i, n) chmin(bucketMinA[i/sqrtN], a[i]);
rep(i, n) chmin(bucketMinB[i/sqrtN], b[i]);
auto push = [&](int k) {
assert(bucketFlagA[k]+bucketFlagB[k] < 2);
//if(!bucketFlagA[k]) return;
if(bucketFlagA[k]) {
reps(i, k*sqrtN, min(n, (k+1)*sqrtN)) a[i] = b[i];
bucketMinA[k] = bucketMinB[k];
bucketFlagA[k] = 0;
} else if(bucketFlagB[k]) {
reps(i, k*sqrtN, min(n, (k+1)*sqrtN)) b[i] = a[i];
bucketMinB[k] = bucketMinA[k];
bucketFlagB[k] = 0;
}
};
auto setA = [&](int y, int z) {
int k = y/sqrtN;
push(k);
a[y] = z;
bucketMinA[k] = inf;
reps(i, k*sqrtN, min(n, (k+1)*sqrtN)) chmin(bucketMinA[k], a[i]);
};
auto setB = [&](int y, int z) {
int k = y/sqrtN;
push(k);
b[y] = z;
bucketMinB[k] = inf;
reps(i, k*sqrtN, min(n, (k+1)*sqrtN)) chmin(bucketMinB[k], b[i]);
};
auto getA = [&](int y, int z) {
int res = inf;
rep(i, bucket_sz) {
int l = i*sqrtN, r = (i+1)*sqrtN;
if(r <= y || z <= l) continue;
if(y <= l && r <= z) {
if(bucketFlagA[i]) chmin(res, bucketMinB[i]);
else chmin(res, bucketMinA[i]);
} else {
push(i);
reps(j, max(l, y), min(r, z)) chmin(res, a[j]);
}
}
return res;
};
auto getB = [&](int y, int z) {
int res = inf;
rep(i, bucket_sz) {
int l = i*sqrtN, r = (i+1)*sqrtN;
if(r <= y || z <= l) continue;
if(y <= l && r <= z) {
if(bucketFlagB[i]) chmin(res, bucketMinA[i]);
else chmin(res, bucketMinB[i]);
} else {
push(i);
reps(j, max(l, y), min(r, z)) chmin(res, b[j]);
}
}
return res;
};
auto copyA = [&]() {
rep(i, bucket_sz) {
if(!bucketFlagB[i]) bucketFlagA[i] = 1;
}
};
auto copyB = [&]() {
rep(i, bucket_sz) {
if(!bucketFlagA[i]) bucketFlagB[i] = 1;
}
};
int q;
cin >> q;
while(q--) {
int x, y, z;
cin >> x >> y >> z;
if(x == 1) setA(y-1, z);
else if(x == 2) setB(y-1, z);
else if(x == 3) cout << getA(y-1, z) << endl;
else if(x == 4) cout << getB(y-1, z) << endl;
else if(x == 5) copyA();
else if(x == 6) copyB();
}
return 0;
}
|
#include "bits/stdc++.h"
#include<unordered_map>
#include<unordered_set>
#pragma warning(disable:4996)
using namespace std;
struct Node {
char val;
shared_ptr<Node>next;
Node() :val(0), next(nullptr) {
}
Node(const Node&node_) :val(node_.val), next(node_.next) {
}
};
shared_ptr<Node>insert(shared_ptr<Node>&node, int pos, char value) {
if (!pos) {
shared_ptr<Node>newNode = make_shared<Node>();
newNode->val = value;
newNode->next = nullptr;
return newNode;
}
else {
node->next = insert(node->next, pos - 1, value);
return node;
}
}
shared_ptr<Node>immutable_insert(const shared_ptr<Node>&node, int pos, char value) {
shared_ptr<Node> copyNode = make_shared<Node>(*node);
if (!pos) {
shared_ptr<Node> newNode = make_shared<Node>();
newNode->val = value;
newNode->next = copyNode;
return newNode;
}
else {
copyNode->next = immutable_insert(node->next, pos - 1, value);
return copyNode;
}
}
namespace perseg {
using Value = int;
const Value ini = INT_MAX;
struct permanent_segtree {
Value val;
int l, r;
vector<shared_ptr<permanent_segtree>>chs;
public:
permanent_segtree(const int size_) :val(ini), l(0), r(size_), chs(2, nullptr) {
}
permanent_segtree(const Value& val_, const int l_, const int r_) :val(val_), l(l_), r(r_), chs(2, nullptr) {
}
permanent_segtree(const permanent_segtree&tree_) :val(tree_.val), l(tree_.l), r(tree_.r), chs(tree_.chs) {
}
shared_ptr<permanent_segtree>getch(const int num_) {
const int amid = (l + r) / 2;
if (chs[num_] == nullptr) {
if (num_ == 0) {
chs[0] = make_shared<permanent_segtree>(ini, l, amid);
}
else {
chs[1] = make_shared<permanent_segtree>(ini, amid, r);
}
}
return chs[num_];
}
Value eval_value(const Value&l, const Value&r)const {
return min(l, r);
}
// min [a, b)
Value query(int a, int b, int k) {
if (r <= a or b <= l) return ini;
if (a <= l and r <= b) return val;
const int m = (l + r) / 2;
const Value al(getch(0)->query(a, b, k));
const Value ar(getch(1)->query(a, b, k));
return eval_value(al, ar);
}
};
shared_ptr<permanent_segtree>immutable_update(const shared_ptr<permanent_segtree>&tree, const int k, const Value a) {
if (k == tree->l&&tree->l + 1 == tree->r) {
shared_ptr<permanent_segtree>new_tree(make_shared<permanent_segtree>(a, tree->l, tree->r));
return new_tree;
}
else {
shared_ptr<permanent_segtree>copy_tree = (make_shared<permanent_segtree>(*tree));
assert(tree->l + 1 < tree->r);
const int amid = (tree->l + tree->r) / 2;
if (k < amid) {
copy_tree->chs[0] = immutable_update(tree->getch(0), k, a);
}
else {
copy_tree->chs[1] = immutable_update(tree->getch(1), k, a);
}
copy_tree->val = copy_tree->eval_value(copy_tree->getch(0)->val, copy_tree->getch(1)->val);
return copy_tree;
}
}
};
int main() {
int N;cin>>N;
using namespace perseg;
vector<std::shared_ptr<permanent_segtree>>trees(2,make_shared<permanent_segtree>(N));
for (int i = 0; i < 2; ++i) {
for (int j = 0; j < N; ++j) {
int a;cin>>a;
trees[i]=immutable_update(trees[i],j,a);
}
}
int Q;cin>>Q;
while (Q--) {
int x,y,z;cin>>x>>y>>z;
x--;
int ope=x/2;
int to=x%2;
if (ope == 0) {
trees[to]=immutable_update(trees[to],y-1,z);
}
else if (ope == 1) {
Value val=trees[to]->query(y-1,z,1);
cout<<val<<endl;
}
else if (ope == 2) {
trees[to]= (make_shared<permanent_segtree>(*trees[!to]));
}
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
#define MAX 300005
#define SZ 500
#define INF (1000000007)
typedef pair<int,int> P;
int a[MAX];
int A[MAX];
int b[MAX];
int B[MAX];
vector< P > ma,mb,mA,mB;
void update(int a[MAX],int A[MAX],vector< P > &ma,vector< P > &mA,int i,int x){
int I=i/SZ;
ma.push_back( P(i,a[i]) );
a[i]=x;
ma.push_back( P(i,a[i]) );
int mini=INF;
for(int i=0;i<SZ;i++){
mini=min(mini, a[ I*SZ + i ] );
}
mA.push_back( P(I,A[I]) );
A[I]=mini;
mA.push_back( P(I,A[I]) );
}
int query(int a[MAX],int A[MAX],int l,int r){
int res=INF;
int i=l;
while(i<r){
if(i%SZ==0 && i+SZ <= r){
res=min(res,A[i/SZ]);
i+=SZ;
}else{
res=min(res,a[i]);
i++;
}
}
return res;
}
void q5(){
reverse(ma.begin(),ma.end());
for(int i=0;i<(int)ma.size();i++){
P p=ma[i];
a[ p.first ] = p.second;
}
reverse(mA.begin(),mA.end());
for(int i=0;i<(int)mA.size();i++){
P p=mA[i];
A[ p.first ] = p.second;
}
for(int i=0;i<(int)mb.size();i++){
P p=mb[i];
a[ p.first ] = p.second;
}
for(int i=0;i<(int)mB.size();i++){
P p=mB[i];
A[ p.first ] = p.second;
}
ma.clear();
mA.clear();
mb.clear();
mB.clear();
}
void q6(){
reverse(mb.begin(),mb.end());
for(int i=0;i<(int)mb.size();i++){
P p=mb[i];
b[ p.first ] = p.second;
}
reverse(mB.begin(),mB.end());
for(int i=0;i<(int)mB.size();i++){
P p=mB[i];
B[ p.first ] = p.second;
}
for(int i=0;i<(int)ma.size();i++){
P p=ma[i];
b[ p.first ] = p.second;
}
for(int i=0;i<(int)mA.size();i++){
P p=mA[i];
B[ p.first ] = p.second;
}
ma.clear();
mA.clear();
mb.clear();
mB.clear();
}
int N,Q;
int main(){
scanf("%d",&N);
for(int i=0;i<N;i++){
int x;
scanf("%d",&x);
update(a,A,ma,mA,i,x);
}
for(int i=0;i<N;i++){
int x;
scanf("%d",&x);
update(b,B,mb,mB,i,x);
}
scanf("%d",&Q);
while(Q--){
int x,y,z;
scanf("%d %d %d",&x,&y,&z);
if(x==1){
update(a,A,ma,mA,y-1,z);
}
if(x==2){
update(b,B,mb,mB,y-1,z);
}
if(x==3){
printf("%d\n", query(a,A,y-1,z) );
}
if(x==4){
printf("%d\n", query(b,B,y-1,z) );
}
if(x==5){
q5();
}
if(x==6){
q6();
}
}
return 0;
} |
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <cmath>
#include <iomanip>
#include <cassert>
#include <bitset>
using namespace std;
typedef pair<int, int> P;
#define rep(i, n) for (int i=0; i<(n); i++)
#define all(c) (c).begin(), (c).end()
#define uniq(c) c.erase(unique(all(c)), (c).end())
#define index(xs, x) (int)(lower_bound(all(xs), x) - xs.begin())
#define _1 first
#define _2 second
#define pb push_back
#define INF 1145141919
#define MOD 1000000007
const int B = 450;
const int MAX_S = (200000/B)+10;
int N, Q, S;
bool lazy[2][MAX_S];
int A[2][200000+B];
int M[2][MAX_S];
void push(int k, int b) {
if (!lazy[k][b]) return;
rep(i, B) A[k][b*B+i] = A[k^1][b*B+i];
lazy[k][b] = false;
}
signed main() {
ios::sync_with_stdio(false); cin.tie(0);
cin >> N;
S = (N-1)/B+1;
rep(k, 2) {
rep(i, S) M[k][i] = INF;
rep(i, N+B) A[k][i] = INF;
rep(i, N) cin >> A[k][i], M[k][i/B] = min(M[k][i/B], A[k][i]);
}
cin >> Q;
rep(i, Q) {
int type, y, z;
cin >> type >> y >> z;
type--;
int k = type%2;
if (type/2 == 0) {
y--;
int b = y/B;
push(k, b);
push(k^1, b);
A[k][y] = z;
M[k][b] = INF;
rep(i, B) M[k][b] = min(M[k][b], A[k][b*B+i]);
}
else if (type/2 == 1) {
y--, z--;
// min [y, z]
int lb=y/B, rb=z/B, m = INF;
push(k, lb);
push(k, rb);
if (lb == rb) {
for (int i=y; i<=z; i++) m = min(m, A[k][i]);
}
else {
for (int i=y; i<(lb+1)*B; i++) m = min(m, A[k][i]);
for (int i=rb*B; i<=z; i++) m = min(m, A[k][i]);
for (int b=lb+1; b<=rb-1; b++) m = min(m, M[k][b]);
}
cout << m << "\n";
}
else {
rep(b, S) {
if (!lazy[k^1][b]) {
lazy[k][b] = true;
M[k][b] = M[k^1][b];
}
}
}
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define int long long
int cnt, a[1000100];
void insertionSort(int a[],int n, int g){
int v,j;
for(int i = g; i < n; i++){
v = a[i];
j = i-g;
while(j >= 0 && a[j] > v){
a[j+g]=a[j];
j-=g;
cnt++;
}
a[j+g] = v;
}
}
void shellSort(int a[], int n){
int m=0,temp=n,j=1, G[100] = {};
for(int i = 1; ; i++){
G[i] = 3*G[i-1]+1;
//cout<<i<<"== "<<G[i]<<endl;
if(G[i] > n)break;
j++;
}
j--;
cout<<j<<endl;
for(int i = j,k=0; i; i--){
if(k++)cout<<" ";
cout<<G[i];
}cout<<endl;
for(int i = j; i; i--){
insertionSort(a,n, G[i]);
}
}
signed main(){
int n;
cin>>n;
for(int i = 0; i < n; i++)
cin>>a[i];
shellSort(a,n);
cout<<cnt<<endl;
for(int i = 0; i < n; i++)
cout<<a[i]<<endl;
return 0;
}
|
#include <iostream>
#include <cstring>
using namespace std;
int n,a[1000000];
int g[100];
int cnt=0;
void shellsort(int j){
int h=g[j];
int i;
for(i=h;i<n;i++){
int v=a[i];
int k=i-h;
while(k>=0&&a[k]>v){
a[k+h]=a[k];
cnt=cnt+1;
k-=h;
}
a[k+h]=v;
}
}
int main()
{
cin>>n;
int i,j,k;
for(i=0;i<n;i++){
cin>>a[i];
}
memset(g,0,sizeof(g));
i=0;
g[i]=1;
//??????????????????
if(n==1)i=1;
else
while(g[i]<n){g[i+1]=g[i++]*3+1;}
cout<<i<<endl;
for(j=i-1;j>=0;j--){
cout<<g[j];
if(j!=0)cout<<" ";
}
cout<<endl;
for(j=i-1;j>=0;j--){
shellsort(j);
}
cout<<cnt<<endl;
for(k=0;k<n;k++){
cout<<a[k]<<endl;
}
return 0;
} |
#include <iostream>
#include <math.h>
using namespace std;
int insSort(int *a, int n, int g) {
int j, key, cnt = 0;
for (int i = g; i < n; i++) {
key = a[i];
j = i - g;
while(( j >= 0) && (a[j] > key)) {
a[j+g] = a[j];
j = j - g;
cnt++;
}
a[j+g] = key;
}
return cnt;
}
int main(){
int n, m, cnt=0;
cin >> n;
int *a = new int[n];
for (int i = 0; i < n; i++)
cin >> a[i];
for (m = 1; m < n + 2; m++) {
if ((pow( 3 , m ) -1) / 2 > n) {
m = m - 1;
break;
}
}
int *g = new int[m];
for (int i = 0; i < m; i++ ) {
g[i] = (pow(3, m - i) -1) / 2;
cnt += insSort(a, n, g[i]);
}
cout << m << endl;
for (int i = 0; i < m - 1; i++ )
cout << g[i] << ' ';
cout << g[m - 1] << endl;
cout << cnt << endl;
for (int i = 0; i < n; i++)
cout << a[i] << endl;
return 0;
} |
#include <iostream>
#include <cmath>
using namespace std;
int an(int m){
if(m==1) return 1;
else{
return 3*an(m-1) + 1;
}
}
int main(){
const int MAX=1000000;
int arr[MAX], G[MAX];
int N, cnt = 0;
cin >> N;
int m = (int)(log(2*N+1)/log(3.0));
for(int i=0; i<m; i++){
G[m-1-i] = an(i+1);
}
for(int i=0; i<N; i++){
cin >> arr[i];
}
for(int k=0; k<m; k++){
int g = G[k];
for(int i=g; i<N; i++){
int v = arr[i];
int j = i - g;
while(j >= 0 && arr[j] > v){
arr[j+g] = arr[j];
j = j - g;
cnt++;
}
arr[j+g] = v;
}
}
cout << m << endl;
for(int i=0; i<m; i++){
if(i==0){
cout << G[i];
}
else{
cout << " " << G[i];
}
}
cout << endl;
cout << cnt << endl;
for(int i=0; i<N; i++){
cout << arr[i] << endl;
}
} |
#include <stdio.h>
int main()
{
int a[1000000]={0},n,i,j,v,m,k,count=0,g[100]={0};
scanf("%d",&n);
for(i=0;i<n;i++){
scanf("%d",&a[i]);
}
i=0;
g[0]=1;
while(1){
if(g[i]>n){
m=i;
break;
}else{
g[i+1]=3*g[i]+i;
i++;
}
}
for(i=0;i<m;i++){
for(j=g[m-1-i];j<n;j++){
v=a[j];
k=j-g[m-1-i];
while(k>=0&&a[k]>v){
a[k+g[m-i-1]]=a[k];
k=k-g[m-i-1];
count++;
}
a[k+g[m-i-1]]=v;
}
}
printf("\n%d\n",m);
for(i=0;i<m;i++){
if(i==m-1) printf("%d\n",g[m-i-1]);
else printf("%d ",g[m-i-1]);
}
printf("%d\n",count);
for(i=0;i<n;i++){
printf("%d\n",a[i]);
}
return 0;
} |
#include <iostream>
#include <algorithm>
using namespace std;
int n, a[1100000], cnt, g[20];
int main()
{
cin >> n;
for (int i = 0; i < n; i++)
scanf("%d", &a[i]);
g[0] = 1;
cnt = 0;
while (true)
{
g[cnt + 1] = g[cnt] * 3 + 1;
if (g[++cnt] >= n)
break;
}
int ret = 0;
for (int i = cnt - 1; i >= 0; i--)
{
for (int j = g[i]; j < n; j++)
{
int v = a[j], w = j - g[i];
while (w >= 0 && a[w] > v)
{
a[w + g[i]] = a[w];
w -= g[i];
ret++;
}
a[w + g[i]] = v;
}
}
cout << cnt << endl;
for (int i = cnt - 1; i >= 0; i--)
printf(i ? "%d " : "%d\n", g[i]);
cout << ret << endl;
for (int i = 0; i < n; i++)
printf("%d\n", a[i]);
return 0;
}
|
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<vector>
using namespace std;
long long c;
int l;
int A[1000000];
int n;
vector<int>G;
void insert(int A[],int n,int g){
for(int i=g;i<n;i++){
int v=A[i];
int j=i-g;
while(j>=0 && A[j]>v){
A[j+g]=A[j];
j-=g;
c++;
}
A[j+g]=v;
}
}
void shell(int A[],int n){
for(int h=1; ;){
if(h>n)break;
G.push_back(h);
h=3*h+1;
}
for(int i=G.size()-1;i>=0;i--){
insert(A,n,G[i]);
}
}
int main(){
cin>>n;
for(int i=0;i<n;i++)scanf("%d",&A[i]);
c=0;
shell(A,n);
cout<<G.size()<<endl;
for(int i=G.size()-1;i>=0;i--){
printf("%d",G[i]);
if(i)printf(" ");
}
printf("\n");
printf("%d\n",c);
for(int i=0;i<n;i++)printf("%d\n",A[i]);
return 0;
} |
#include <iostream>
#include <algorithm>
using namespace std;
int n, a[1111111], c, g[20];
int main() {
// cin.tie(0);
// ios::sync_with_stdio(false);
cin >> n;
for(int i = 0; i < n; i++) {
cin >> a[i];
}
g[0] = 1; c = 0;
while(true) {
g[c + 1] = g[c] * 3 + 1;
if(g[++c] >= n) break;
}
int ret = 0;
for(int i = c - 1; i >= 0; i--) {
for(int j = g[i]; j < n; j++) {
int v = a[j], w = j - g[i];
while(w >= 0 && a[w] > v) {
a[w + g[i]] = a[w];
w -= g[i];
ret++;
}
a[w + g[i]] = v;
}
}
cout << c << endl;
for(int i = c - 1; i >= 0; i--) {
if(i) cout << g[i] << ' ';
else cout << g[i] << endl;
}
cout << ret << endl;
for(int i = 0; i < n; i++) {
cout << a[i] << endl;
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
int cnt = 0;
void insertionSort(int a[], int n, int g) {
for (int i=g; i<n; i++) {
int v = a[i];
int j = i - g;
while (j >= 0 && a[j] > v) {
a[j+g] = a[j];
j -= g;
cnt++;
}
a[j+g] = v;
}
}
void shellSort(int a[], int n) {
vector<int> G;
int h = 1;
while (h <= n) {
G.push_back(h);
h = 3 * h + 1;
}
for (int i=G.size()-1; i>=0; i--)
insertionSort(a, n, G[i]);
// print info
cout << G.size() << endl;
if (G.size() > 0) {
for (int i=G.size()-1; i>0; i--)
cout << G[i] << " ";
cout << G[0] << endl;
}
}
int main() {
int n;
cin >> n;
int a[n];
for (int i=0; i<n; i++) cin >> a[i];
shellSort(a, n);
cout << cnt << endl;
for (int i=0; i<n; i++) cout << a[i] << endl;;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long cnt;
int l;
int A[1000000];
int N;
vector<int> G;
void insertionSort(int A[], int N, int g){
int v;
for(int i=g;i<N;i++){
v=A[i];
int j=i-g;
while(j >=0 && A[j]>v){
A[j+g]=A[j];
j=j-g;
cnt++;
}
A[j+g]=v;
}
}
void shellSort(int A[],int N){
for(int h=1;;){
if(h>N){
break;
}
G.push_back(h);
h = 3*h+1;
}
for(int i = G.size()-1;i>=0;i--){
insertionSort(A,N,G[i]);
}
}
int main() {
cin >> N;
for(int i =0;i<N;i++){
cin >>A[i];
}
cnt = 0;
shellSort(A,N);
cout <<G.size()<<endl;
for(int i=G.size()-1;i>=0;i--){
cout <<G[i];
if(i>0){
cout <<" ";
}
}
cout <<endl;
printf("%d\n", cnt);
for(int i = 0 ; i<N ; i++){
printf("%d\n", A[i]);
}
return 0;
}
|
#include <iostream>
using namespace std;
int N, *A;
int cnt;
void isort(int *A, int n, int g) {
for (auto i = g; i < n; i++) {
auto v = A[i];
int j;
for (j = i - g; j >= 0 && A[j] > v; j -= g) {
A[j+g] = A[j];
cnt++;
}
A[j+g] = v;
}
}
void shsort(int *A, int n) {
cnt = 0;
int m = 0;
int G[] = {1, 4, 13, 40, 121, 364, 1093, 3280, 9841, 29524, 88573, 265720, 797161};
for (; G[m] <= n; m++);
cout << m << endl;
for (auto i = m - 1; i >= 0; i--) {
if (i != m - 1) cout << " ";
cout << G[i];
isort(A, n, G[i]);
}
cout << endl;
cout << cnt << endl;
}
int main(void){
cin >> N;
A = new int[N];
for (auto i = 0; i < N; i++) cin >> A[i];
shsort(A, N);
for (int i = 0; i < N; i++) cout << A[i] << endl;
delete[] A;
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
const int maxn=1e6+5;
int s[maxn],n,cnt;
vector<int>v;
void insertionsort(int g)
{
for(int i=g;i<n;i++){
int v=s[i],j=i-g;
while(j>=0&&s[j]>v){
s[j+g]=s[j];
j-=g;
cnt++;
}
s[j+g]=v;
}
}
void shellsort()
{
for(int h=1;;){
if(h>n){
break;
}
v.push_back(h);
h=h*3+1;
}
int len=v.size()-1;
for(int i=len;i>=0;i--){
insertionsort(v[i]);
}
}
int main()
{
scanf("%d",&n);
for(int i=0;i<n;i++){
scanf("%d",&s[i]);
}
shellsort();
cout<<v.size()<<endl;
for(int i=v.size()-1;i>=0;i--){
printf("%d",v[i]);
if(i){
printf(" ");
}
}
printf("\n");
printf("%d\n",cnt);
for(int i=0;i<n;i++){
printf("%d\n",s[i]);
}
return 0;
}
/*
5
5 1 4 3 2
*/
|
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
using namespace std;
long long cnt;
int l;
int A[1000000];
int n;
vector<int> G;
void insertionSort(int A[],int n,int g){
for(int i=g;i<n;i++){
int v=A[i];
int j=i-g;
while(j>=0&&A[j]>v){
A[j+g]=A[j];
j-=g;
cnt++;
}
A[j+g]=v;
}
}
void shellSort(int A[],int n){
for(int h=1;;){
if(h>n)break;
G.push_back(h);
h=3*h+1;
}
for(int i=G.size()-1;i>=0;i--){
insertionSort(A,n,G[i]);
}
}
int main() {
cin>>n;
for(int i=0;i<n;i++) cin>>A[i];
cnt=0;
shellSort(A,n);
cout<<G.size()<<endl;
for(int i=G.size()-1;i>=0;i--){
cout<<G[i];
if(i) cout<<" ";
}
cout<<endl;
cout<<cnt<<endl;
for(int i=0;i<n;i++){
cout<<A[i]<<endl;
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define MAX 1000000
int A[MAX];
int insertionSort(int n, int g){
int cnt = 0;
for(int i=g; i<n; i++){
int t = A[i];
int j;
for(j=i-g; j>=0 && A[j]>t; j-=g){
A[j+g] = A[j];
cnt++;
}
A[j+g] = t;
}
return cnt;
}
int shellSort(int n){
int cnt = 0;
int m = 13;
int g[13];
for(int i=0; i<13; i++){
g[i] = (pow(3, i+1) - 1 ) / 2;
if(g[i] > n){
m = i;
break;
}
}
for(int i=0; i<m; i++){
cnt += insertionSort(n, g[m-1-i]);
}
cout << m << "\n";
cout << g[m-1]; for(int i=m-2; i>=0; i--) cout << " " << g[i]; cout << "\n";
cout << cnt << "\n";
for(int i=0; i<n; i++) cout << A[i] << "\n";
cout << flush;
return 0;
}
int main(){
int n;
cin >> n;
for(int i=0; i<n; i++) cin >> A[i];
shellSort(n);
return 0;
}
|
#include<iostream>
#include<vector>
using namespace std;
long long cnt;
int m = 0;
int A[1000000];
vector<int> G;
void insertSort(int A[], int n, int g) {
for (int i = g; i < n; i++) {
int v = A[i];
int j = i - g;
while (j >= 0 && A[j] > v) {
A[j + g] = A[j];
j = j - g;
cnt++;
}
A[j+g] = v;
}
}
void shellSort(int A[], int n) {
for (int h = 1;;) {
if (h > n) { break; }
G.push_back(h);
h = 3 * h + 1;
}
for (int i = G.size() - 1; i >= 0; i--) {
insertSort(A, n, G[i]);
}
}
int main()
{
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> A[i];
}
shellSort(A,n);
cout <<G.size()<< endl;
for (int i = G.size()-1; i>=0; i--) {
cout << G[i]<<" ";
}
cout << endl;
cout << cnt << endl;
for (int i = 0; i < n; i++) {
cout << A[i] << endl;
}
}
|
#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <cmath>
using namespace std;
int cnt = 0;
void insertionSort(vector<int> &A,int g){
int n = A.size();
for(int i = g; i < n; i++){
int v = A[i];
int j = i - g;
while(j >= 0 and A[j] > v){
A[j+g] = A[j];
j = j - g;
cnt++;
}
A[j+g] = v;
}
}
void shellSort(vector<int> &A){
cnt = 0;
int n = A.size(),i;
vector<int> G;
for(i = 1; i <= n; i = 3*i+1) G.push_back(i);
reverse(G.begin(),G.end());
int m = G.size();
cout << m << endl;
for(i = 0; i < m; i++) printf(i < m-1 ? "%d ":"%d\n",G[i]);
for(i = 0; i < m; i++) insertionSort(A,G[i]);
}
int main(){
int n;
cin >> n;
vector<int> A(n);
for(auto &a:A) cin >> a;
shellSort(A);
cout << cnt << endl;
for(auto a:A){
cout << a << endl;
}
return 0;
} |
#include <algorithm>
#include <cstdio>
#include <vector>
static const size_t N_MAX = 1000000;
static int A[N_MAX];
int main() {
size_t N;
scanf("%zu", &N);
for (size_t i = 0; i < N; i++)
scanf("%d", A + i);
std::vector<size_t> G;
for (auto i = 1; unsigned((1 << i) - 1) <= N; i++)
G.push_back((1 << i) - 1);
std::reverse(G.begin(), G.end());
int c = 0;
for (auto&& g : G)
for (size_t i = g; i < N; i++) {
auto v = A[i];
size_t j = i;
while (j >= g && A[j-g] > v) {
A[j] = A[j-g];
j -= g;
c++;
}
A[j] = v;
}
printf("%zu\n", G.size());
for (size_t i = 0; i < G.size() - 1; i++)
printf("%zu ", G[i]);
printf("%zu\n", G.back());
printf("%d\n", c);
for (size_t i = 0; i < N; i++)
printf("%d\n", A[i]);
return 0;
} |
#include <iostream>
#include <algorithm>
using namespace std;
int n, a[1111111], c, g[20];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n;
for(int i = 0; i < n; i++) {
cin >> a[i];
}
g[0] = 1; c = 0;
while(true) {
g[c + 1] = g[c] * 3 + 1;
if(g[++c] >= n) break;
}
int ret = 0;
for(int i = c - 1; i >= 0; i--) {
for(int j = g[i]; j < n; j++) {
int v = a[j], w = j - g[i];
while(w >= 0 && a[w] > v) {
a[w + g[i]] = a[w];
w -= g[i];
ret++;
}
a[w + g[i]] = v;
}
}
cout << c << endl;
for(int i = c - 1; i >= 0; i--) {
if(i) cout << g[i] << ' ';
else cout << g[i] << endl;
}
cout << ret << endl;
for(int i = 0; i < n; i++) {
cout << a[i] << endl;
}
return 0;
} |
#include<iostream>
#include<cmath>
using namespace std;
#include<vector>
#define ArrayNum 1000000
vector<int> g;
int insertionSort(int a[],int n,int g){
int i,j,cnt=0,v;
for(i=g;i<n;i++){
v= a[i];
j=i-g;
while(j>=0 && a[j]>v){
a[j+g]=a[j];
j=j-g;
cnt++;
}
a[j+g]=v;
}
return cnt;
}
void shellSort(int a[], int n){
int i,cnt=0,m;
for(int h=1;;){
if(h>n)
break;
g.push_back(h);
h=3*h+1;
}
m=g.size();
for(i=m-1;i>=0;i--)
cnt=cnt+insertionSort(a,n,g[i]);
cout << m << "\n";
for(i=m-1;i>0;i--)
cout << g[i] << " ";
cout << g[0] << "\n";
cout << cnt << "\n";
for(i=0;i<n;i++)
cout << a[i] << "\n";
}
int main(void){
int i,n,a[ArrayNum];
cin >> n;
for(i=0;i<n;i++)
cin >> a[i];
shellSort(a,n);
}
|
#include <cstdio>
#include <vector>
#include <utility>
#include <algorithm>
#include <cmath>
using namespace std;
static inline void p(int x) { printf("%d\n", x); }
int main()
{
int n, cnt = 0;
scanf("%d", &n);
vector<int> A(n), G;
for (int &x: A)
scanf("%d", &x);
for (int i = 1, x = 1; x <= n; x = pow(4,i)+3*pow(2,i-1)+1, i++)
G.push_back(x);
reverse(G.begin(), G.end());
for (int g: G)
for (auto b = A.begin(), i = b + g, e = A.end(); i != e; i++) {
int v = *i;
auto j = i - g;
for(; j >= b && *j > v; j -= g)
*(j + g) = *j, cnt++;
*(j + g) = v;
}
p(G.size());
for (int &x: G)
printf("%s%d", (&x == &G[0] ? "" : " "), x);
puts("");
p(cnt);
for (int x: A)
p(x);
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.