├── Solucionario regional 2019
    ├── G.cpp
    ├── F.cpp
    ├── M.cpp
    ├── E.cpp
    ├── K.cpp
    ├── I.cpp
    ├── L.cpp
    ├── D.cpp
    ├── A.cpp
    └── C.cpp
├── solucionario regional 2012
    ├── E.exe
    ├── d.cpp
    ├── h.cpp
    ├── b.cpp
    ├── c.cpp
    ├── E.cpp
    ├── i.cpp
    ├── f.cpp
    ├── a.cpp
    ├── g.cpp
    └── j.cpp
├── solucionario regional 2015
    ├── e.cpp
    ├── i.cpp
    ├── j.cpp
    ├── d.cpp
    ├── a_greedy.cpp
    ├── c.cpp
    ├── a_dinamica.cpp
    ├── k.cpp
    ├── g.cpp
    ├── b.cpp
    ├── k2.cpp
    ├── f.cpp
    ├── h.cpp
    └── e2.cpp
├── solucionario regional 2017
    ├── m.cpp
    ├── h.cpp
    ├── E.cpp
    ├── b.cpp
    ├── j.cpp
    ├── C.cpp
    ├── g.cpp
    ├── d.cpp
    ├── f.cpp
    ├── i.cpp
    ├── a.cpp
    ├── k.cpp
    └── L.cpp
├── Readme.txt
├── solucionario regional 2016
    ├── a.cpp
    ├── j.cpp
    ├── f.cpp
    ├── h.cpp
    ├── d.cpp
    ├── g.cpp
    ├── c.cpp
    ├── i.cpp
    ├── b.cpp
    └── k.cpp
└── solucionario regional 2013
    ├── c.cpp
    ├── I.cpp
    ├── d.cpp
    ├── f.cpp
    ├── e.cpp
    ├── g.cpp
    ├── a.cpp
    ├── h.cpp
    ├── j.cpp
    └── b.cpp


/Solucionario regional 2019/G.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jonathandrnd/ACMICPC_LatinAmericaSolution/HEAD/Solucionario regional 2019/G.cpp


--------------------------------------------------------------------------------
/solucionario regional 2012/E.exe:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jonathandrnd/ACMICPC_LatinAmericaSolution/HEAD/solucionario regional 2012/E.exe


--------------------------------------------------------------------------------
/solucionario regional 2015/e.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jonathandrnd/ACMICPC_LatinAmericaSolution/HEAD/solucionario regional 2015/e.cpp


--------------------------------------------------------------------------------
/solucionario regional 2017/m.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jonathandrnd/ACMICPC_LatinAmericaSolution/HEAD/solucionario regional 2017/m.cpp


--------------------------------------------------------------------------------
/Readme.txt:
--------------------------------------------------------------------------------
1 | Solutions ACM ICPC - Latin America 
2 | -----------------------------------------------------------------
3 | 
4 | The analysis are published in my blog https://chococontest.wordpress.com (Spanish)
5 | 


--------------------------------------------------------------------------------
/solucionario regional 2016/a.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<algorithm>
 3 | using namespace std;
 4 | 
 5 | int main(){
 6 | 	
 7 | 	int a,b,c,d;
 8 | 	while(cin>>a>>b>>c>>d){
 9 | 		cout<< abs( (a+d)-(b+c)) <<endl;
10 | 	}
11 | 
12 |     return 0;
13 | }
14 | 


--------------------------------------------------------------------------------
/solucionario regional 2017/h.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<cstring>
 3 | #include<cstdio>
 4 | #include<vector>
 5 | #include<cmath>
 6 | #include<sstream>
 7 | #include<algorithm>
 8 | #include<set>
 9 | #include<queue>
10 | using namespace std;
11 | 
12 | int main(){
13 | 	//freopen("in.txt","r",stdin);
14 | 	//freopen("out.txt","w",stdout);
15 | 	int ca,ba,pa;
16 | 	int cr,br,pr;
17 | 	
18 | 	while(cin>>ca>>ba>>pa>>cr>>br>>pr){
19 | 		cout<<max(cr-ca,0)+max(br-ba,0)+max(pr-pa,0)<<endl;
20 | 	}
21 | 	
22 | 	return 0;
23 | }
24 | 
25 | 
26 | 


--------------------------------------------------------------------------------
/solucionario regional 2015/i.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<cstring>
 3 | #include<cstdio>
 4 | #include<algorithm>
 5 | #include<sstream>
 6 | #include<set>
 7 | #include<cstring>
 8 | #include<vector>
 9 | #include<map>
10 | #include<cassert>
11 | #include<cmath>
12 | #include<queue>
13 | using namespace std;
14 | 
15 | int main(){
16 | //freopen("in.txt","r",stdin);
17 | //freopen("out.txt","w",stdout);
18 | 
19 |     int t;
20 | 
21 |     while(cin>>t){
22 |         int x;int cont=0;
23 |         for(int i=0;i<5;i++){
24 |             cin>>x;
25 |             if(x==t)cont++;
26 |         }
27 |         cout<<cont<<endl;
28 |     }
29 | 
30 | 
31 |     return 0;
32 | }
33 | 
34 | 
35 | 


--------------------------------------------------------------------------------
/solucionario regional 2016/j.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<cstring>
 3 | #include<cstdio>
 4 | #include<vector>
 5 | #include<cmath>
 6 | #include<sstream>
 7 | #include<algorithm>
 8 | #include<set>
 9 | #include<cassert>
10 | #include<queue>
11 | #include<map>
12 | using namespace std;
13 | 
14 | bool isprime(int n){
15 | 	
16 | 	for(int i=2;i*i<=n;i++)
17 | 		if(n%i==0)return 0;
18 | 	return 1;
19 | }
20 | 
21 | int main(){
22 | 	//freopen("in.txt","r",stdin);
23 | 	//freopen("out.txt","w",stdout);
24 | 	
25 | 	int n;
26 | 	while(cin>>n){
27 | 		if(n==2){
28 | 			cout<<n<<endl;
29 | 			continue;
30 | 		}
31 | 		
32 | 		if(n%2==0)n--;
33 | 		
34 | 		while(!isprime(n)){
35 | 			n-=2;
36 | 		}
37 | 		
38 | 		cout<<n<<endl;
39 | 	}
40 | 	
41 |     return 0;
42 | }
43 | 
44 | 


--------------------------------------------------------------------------------
/solucionario regional 2016/f.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<cstring>
 3 | #include<cstdio>
 4 | #include<vector>
 5 | #include<cmath>
 6 | #include<sstream>
 7 | #include<algorithm>
 8 | #include<set>
 9 | #include<cassert>
10 | #include<queue>
11 | #include<map>
12 | using namespace std;
13 | 
14 | int main(){
15 | 	
16 | 	int N,C,S;
17 | 	
18 | 	while(cin>>N>>C>>S){
19 | 		int position=1;
20 | 		int count=(S==1);
21 | 		
22 | 		for(int i=0;i<C;i++){
23 | 			int command;
24 | 			scanf("%d",&command);
25 | 			
26 | 			if(command==-1){
27 | 				if(position==1)position=N;
28 | 				else position--;
29 | 			}else{
30 | 				if(position==N)position=1;
31 | 				else position++;
32 | 			}
33 | 			
34 | 			count+=(S==position);
35 | 		}
36 | 		
37 | 		cout<<count<<endl;
38 | 	}
39 | 	
40 |     return 0;
41 | }
42 | 
43 | 


--------------------------------------------------------------------------------
/solucionario regional 2016/h.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<cstring>
 3 | #include<cstdio>
 4 | #include<vector>
 5 | #include<numeric>
 6 | #include<cmath>
 7 | #include<sstream>
 8 | #include<algorithm>
 9 | #include<set>
10 | using namespace std;
11 | int p[100005];
12 | int n,k;
13 | 
14 | 
15 | int main(){
16 | 	
17 | 	while(scanf("%d %d",&n,&k)==2){
18 | 		int sum=0;
19 | 		for(int i=0;i<n;i++){
20 | 			scanf("%d",&p[i]);
21 | 			sum+=p[i];
22 | 		}
23 | 		
24 | 		multiset<int>S;
25 | 		
26 | 		for(int i=0;i<n;i++){
27 | 			S.insert(p[i]);
28 | 			int tam=(i+1)/(k+1);
29 | 			
30 | 			while(S.size()>tam){
31 | 				S.erase(S.begin());
32 | 			}
33 | 		}
34 | 		
35 | 		vector<int>join(S.begin(),S.end());
36 | 		cout<<sum- (int)accumulate(join.begin(),join.end(),0)<<endl;
37 | 	}
38 | 	
39 |     return 0;
40 | }
41 | 


--------------------------------------------------------------------------------
/Solucionario regional 2019/F.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <cstring>
 3 | #include <cmath>
 4 | #include <map>
 5 | #include <vector>
 6 | #include <string>
 7 | #include <algorithm>
 8 | #include <set>
 9 | #include <map>
10 | #include <unordered_map>
11 | using namespace std;
12 | long long memo[5002][5002];
13 | 
14 | long long dp(int S, int B){
15 | 	if( S <= 0) return ( B == 0);
16 | 	if( B < 0 || S < 0) return 0; 
17 | 	if(memo[S][B] != -1)return memo[S][B];
18 | 	
19 | 	long long ans = 2*dp(S - 1, B) - dp(S - 2, B) + dp(S, B - S);
20 | 	ans = ans%1000000007;
21 | 	if(ans<0) ans += 1000000007;
22 | 	memo[S][B] = ans;
23 | 	return ans;
24 | }
25 | 
26 | int main(){
27 |    	memset(memo,-1,sizeof(memo));
28 | 	int S,B;
29 |    	
30 |    	while(cin>>S>>B){
31 |    		cout<<dp(S,B-S)<<endl;
32 | 	}
33 |    	
34 |    	return 0;
35 | }
36 | 


--------------------------------------------------------------------------------
/Solucionario regional 2019/M.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <cstring>
 3 | #include <cmath>
 4 | #include <map>
 5 | #include <vector>
 6 | #include <string>
 7 | #include <algorithm>
 8 | #include <set>
 9 | #include <map>
10 | #include <unordered_map>
11 | using namespace std;
12 | vector<int>nextEgg;
13 | 
14 | int main() {
15 | 	//freopen("in.txt","r",stdin);
16 | 	//freopen("out.txt","w",stdout);
17 | 	
18 | 	int n, x;
19 | 	
20 | 	while(cin>>n>>x){
21 | 		
22 | 		vector<int>v(n,-1);
23 | 		for(int i = 0; i < n; i++)
24 | 			cin>>v[i];
25 | 		
26 | 		int ans = 0;
27 | 		
28 | 		for(int i=  0; i < n;){
29 | 			int cnt = 0;
30 | 			int last = v[i];
31 | 			
32 | 			while(i <n && last + x >= v[i] ){
33 | 				last = v[i];
34 | 				cnt++;
35 | 				i++;
36 | 			}
37 | 			
38 | 			ans = max(ans, cnt);
39 | 		}
40 | 		
41 | 		cout<<ans<<endl;
42 | 	}
43 | 		
44 | 	return 0;
45 | }
46 | 


--------------------------------------------------------------------------------
/solucionario regional 2015/j.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <cstdio>
 3 | #define f(i,x,y) for(int i = x; i < y; i++)
 4 | using namespace std;
 5 | typedef long long ll;
 6 | 
 7 | ll mod = 1e9 + 7;
 8 | ll modpow(ll a, ll pot) {
 9 | 	ll res = 1;
10 | 	for (; pot; pot >>= 1) {
11 | 		if (pot&1) res = res * a % mod;
12 | 		a = a * a % mod;
13 | 	}
14 | 	return res;
15 | }
16 | 
17 | ll C[5005], P[5005];
18 | 
19 | int main(){
20 | 	int n, q;
21 | 	while ( scanf("%d%d", &n, &q) == 2 ){
22 | 		f(i, 0, n + 1) P[i] = modpow(i, n);
23 | 		C[0] = 1;
24 | 		f(i, 1, n) C[i] = C[i-1] * (n-i+1) % mod * modpow(i, mod-2) % mod;
25 | 		int x;
26 | 		f(t, 0, q){
27 | 			scanf("%d", &x);
28 | 			x = min(x, n);
29 | 			ll ans = 0;
30 | 			f(i,0,x){
31 | 				ans += (i&1? -1 : 1) * C[i] * P[x - i] % mod;
32 | 			}
33 | 			ans = (ans % mod + mod) % mod;
34 | 			printf("%lld%c", ans, t+1 == q? 10 : 32);
35 | 		}
36 | 	}
37 | 	
38 | 	return 0;
39 | }
40 | 


--------------------------------------------------------------------------------
/Solucionario regional 2019/E.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <cstring>
 3 | #include <cmath>
 4 | #include <map>
 5 | #include <vector>
 6 | #include <string>
 7 | #include <algorithm>
 8 | #include <set>
 9 | #include <map>
10 | #include <unordered_map>
11 | using namespace std;
12 | vector<int>nextEgg;
13 | string s;
14 | 
15 | int main() {
16 | 	int t;
17 | 	
18 | 	while( cin >> s ){
19 | 		s += s;		
20 | 		cin >> t;
21 | 		int n = s.size();
22 | 		
23 | 		nextEgg = vector<int>(n+1);
24 | 		nextEgg[n]= -1;
25 | 		
26 | 		for(int i = n-1; i >= 0; i--){
27 | 			if(s[i] == 'E') nextEgg[i] = i;
28 | 			else nextEgg[i] = nextEgg[i+1];
29 | 		}
30 | 		
31 | 		long long ans = 0;
32 | 		
33 | 		for(int i = 0; i < n/2; i++){
34 | 			int index = nextEgg[i];
35 | 			if(index >= i + t || index == -1)continue;
36 | 			ans +=  (i+t-index);
37 | 		}
38 | 		
39 | 		cout<<ans<<endl;
40 | 	}
41 | 	
42 | 		
43 | 	return 0;
44 | }
45 | 


--------------------------------------------------------------------------------
/solucionario regional 2012/d.cpp:
--------------------------------------------------------------------------------
 1 | #include <ctime>
 2 | #include <numeric>
 3 | #include <functional>
 4 | #include <iostream>
 5 | #include <vector>
 6 | #include <algorithm>
 7 | #include <bitset>
 8 | #include <string>
 9 | #include <cstring>
10 | #include <climits>
11 | #include <cmath>
12 | #include <cctype>
13 | #include <sstream>
14 | #include <map>
15 | #include <set>
16 | #include <cstdio>
17 | #include <queue>
18 | using namespace std;
19 | 
20 | int f(int t){
21 |     bitset<10>visited;
22 |      
23 |     while(t!=0){
24 |         if(visited[t%10])return 0;
25 |         visited[t%10]=1;
26 |         t/=10;    
27 |     }
28 |     
29 |     return 1;
30 | }
31 |  
32 | int main(){
33 |     //freopen("in.txt","r",stdin);
34 |     //freopen("out.txt","w",stdout);
35 |    
36 |     int c[5001];
37 |     c[0]=0;
38 |     
39 |     for(int i=1;i<=5000;i++)
40 |         c[i]=c[i-1]+f(i);
41 |     
42 |     int a,b;
43 |     while(scanf("%d %d",&a,&b)==2){
44 |         printf("%d\n",c[b]-c[a-1]);
45 |     }
46 |     
47 |     return 0;
48 | }
49 | 


--------------------------------------------------------------------------------
/solucionario regional 2012/h.cpp:
--------------------------------------------------------------------------------
 1 | #include <ctime>
 2 | #include <numeric>
 3 | #include <functional>
 4 | #include <iostream>
 5 | #include <vector>
 6 | #include <algorithm>
 7 | #include <bitset>
 8 | #include <string>
 9 | #include <cstring>
10 | #include <climits>
11 | #include <cmath>
12 | #include <cctype>
13 | #include <sstream>
14 | #include <map>
15 | #include <set>
16 | #include <cstdio>
17 | #include <queue>
18 | using namespace std;
19 | 
20 | 
21 | int main(){
22 |     //freopen("in.txt","r",stdin);
23 |     //freopen("out.txt","w",stdout);
24 |    
25 |     int n;
26 |     bool visited[360];
27 |     memset(visited,0,sizeof(visited));
28 |     
29 |     for(int i=0;i<12;i++){
30 |         for(int j=0;j<60;j++){
31 |             int ang1=30*i+ 6*(j/12);
32 |             int ang2=6*j;
33 |             int mini=min(abs(ang1-ang2),360-abs(ang1-ang2));
34 |             visited[mini]=1;    
35 |         }
36 |     }
37 |     
38 |     while(cin>>n){
39 |         if(visited[n])
40 |             cout<<"Y"<<endl;
41 |         else
42 |             cout<<"N"<<endl;
43 |     }
44 |     
45 |     return 0;
46 | }
47 | 


--------------------------------------------------------------------------------
/solucionario regional 2016/d.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<cstring>
 3 | #include<cstdio>
 4 | #include<vector>
 5 | #include<cmath>
 6 | #include<sstream>
 7 | #include<algorithm>
 8 | #include<set>
 9 | #include<cassert>
10 | #include<queue>
11 | #include<map>
12 | using namespace std;
13 | 
14 | int main(){
15 | 
16 | 	int n;
17 | 	while(scanf("%d",&n)==1){
18 | 		int S[n];
19 | 		for(int i=0;i<n;i++)
20 | 			scanf("%d",&S[i]);
21 | 		
22 | 		sort(S,S+n);
23 | 		
24 | 		int S2[n];
25 | 		
26 | 		if(n%2==1){
27 | 			int pos=n-1;
28 | 			S2[n/2]=S[pos--];
29 | 			for(int i=1;i<=n/2;i++){
30 | 				S2[n/2-i]=S[pos--];
31 | 				S2[n/2+i]=S[pos--];
32 | 			}
33 | 		}else{
34 | 			int pos=n-1;
35 | 			for(int i=0;i<n/2;i++){
36 | 				S2[n/2-i-1]=S[pos--];
37 | 				S2[n/2+i]=S[pos--];
38 | 			}
39 | 		}
40 | 		
41 | 		
42 | 		double area=0;
43 | 		
44 | 		double pi=acos(-1);
45 | 		double angle=(pi*(n-2))/n;
46 | 		long long sarea=0;
47 | 		
48 | 		
49 | 		for(int i=0;i<n;i++)
50 | 			sarea+= (S2[i]*S2[(i+1)%n]); 			
51 | 		
52 | 		
53 | 		area=sarea;
54 | 		area*=sin(angle)/2;
55 | 		printf("%.3lf\n",area);
56 | 		
57 | 	}
58 | 	
59 | 
60 | 
61 |     return 0;
62 | }
63 | 
64 | // area   S1*S2*sin(angle)
65 | 		
66 | 


--------------------------------------------------------------------------------
/solucionario regional 2016/g.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <vector>
 3 | #include <algorithm>
 4 | using namespace std;
 5 | #define f(i,x,y) for(int i = x; i < y; ++ i)
 6 | typedef long long ll;
 7 | 
 8 | int KMP(const vector<int>& S, const vector<int>& K)
 9 | {
10 | 	int ans = 0;
11 | 	int n = S.size(), m = K.size();
12 | 	vector<int> T(m + 1);
13 | 
14 | 	int j = T[0] = -1;
15 | 	f(i, 0, m)
16 | 	{
17 | 		while( ~j && K[i] != K[j] && (K[j] || K[i] <= j) ) j = T[j];
18 | 		T[i + 1] = ++ j;
19 | 	}
20 | 
21 | 	j = 0;
22 | 	f(i, 0, n)
23 | 	{
24 | 		while( ~j && S[i] != K[j] && (K[j] || S[i] <= j) ) j = T[j];
25 | 		++ j;
26 | 		if( j == m ) ++ ans, j = T[j];
27 | 	}
28 | 	return ans;
29 | }
30 | 
31 | int main()
32 | {
33 | 	ios::sync_with_stdio(0);
34 | 	string w; cin >> w;
35 | 	int n = w.size();
36 | 	vector<int> s(n);
37 | 
38 | 	vector<int> last(26, -1);
39 | 	f(i, 0, n)
40 | 	{
41 | 		char c = w[i] - 'a';
42 | 		s[i] = last[c] == -1? 0 : i - last[c];
43 | 		last[c] = i;
44 | 	}
45 | 
46 | 	last.assign(26, -1);
47 | 
48 | 	int m; cin >> m;
49 | 	vector<int> k(m);
50 | 	f(i, 0, m)
51 | 	{
52 | 		int x; cin >> x; -- x;
53 | 		k[i] = last[x] == -1? 0 : i - last[x];
54 | 		last[x] = i;
55 | 	}
56 | 	cout << KMP(s, k) << endl;
57 | }
58 | 
59 | 


--------------------------------------------------------------------------------
/solucionario regional 2012/b.cpp:
--------------------------------------------------------------------------------
 1 | #include <ctime>
 2 | #include <numeric>
 3 | #include <functional>
 4 | #include <iostream>
 5 | #include <vector>
 6 | #include <algorithm>
 7 | #include <bitset>
 8 | #include <string>
 9 | #include <cstring>
10 | #include <climits>
11 | #include <cmath>
12 | #include <cctype>
13 | #include <sstream>
14 | #include <map>
15 | #include <set>
16 | #include <cstdio>
17 | #include <queue>
18 | using namespace std;
19 | #define MOD 1000000007
20 | long long S,B;
21 | 
22 | long long memo[101][201][201];
23 | 
24 | long long dp(int pos,int piedras,int val){
25 |     
26 |     if(pos==0){
27 |         if(val==0 && piedras==0)return 1;    
28 |         return 0;
29 |     }
30 |     
31 |     if(memo[pos][piedras][val]!=-1)return memo[pos][piedras][val];
32 |     long long dev=dp(pos-1,piedras,val/2);
33 |     if(piedras>0)
34 |         dev= (dev+dp(pos,piedras-1,val+1))%MOD;
35 |     
36 |     memo[pos][piedras][val]=dev;
37 |     return dev;
38 | }
39 | 
40 | int main(){
41 |     
42 |     //freopen("in.txt","r",stdin);
43 |     //freopen("out.txt","w",stdout);
44 |     
45 |     int n;
46 |     memset(memo,-1,sizeof(memo));
47 |     
48 |     while(cin>>S>>B){
49 |         cout<<dp(B-1,S,0)%MOD<<endl;
50 |     }
51 |     
52 |     return 0;
53 | }
54 | 


--------------------------------------------------------------------------------
/solucionario regional 2015/d.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<cstring>
 3 | #include<cstdio>
 4 | #include<algorithm>
 5 | #include<sstream>
 6 | #include<set>
 7 | #include<vector>
 8 | #include<map>
 9 | #include<cassert>
10 | #include<queue>
11 | using namespace std;
12 | 
13 | int main(){
14 | 
15 |     int n,m;
16 |     
17 |     while(cin>>n>>m){
18 |         int dev=0;
19 |         int budget,tengo,aux;
20 |         
21 |         for(int i=0;i<m;i++){
22 |             cin>>budget;
23 |             cin>>tengo;
24 |             int sum=0;
25 |             for(int j=0;j<n-1;j++){
26 |                 cin>>aux;
27 |                 sum+=aux;
28 |             }
29 |             
30 |             if(sum>budget)continue;
31 |             int win=0;
32 |             if(sum+tengo<=budget)
33 |                 win=tengo;
34 |                 
35 |             int diez=1;
36 |             int maxi=0;
37 |             for(int j=0;j<5;j++){
38 |                 if(sum+diez<=budget){
39 |                     maxi=max(maxi,diez);
40 |                 }
41 |                 diez*=10;
42 |             }
43 |             
44 |             dev+=maxi-win;
45 |         }
46 |         
47 |         cout<<dev<<endl;
48 |     }
49 | 
50 |     return 0;
51 | }
52 | 
53 | 
54 | 
55 | 
56 | 
57 | 


--------------------------------------------------------------------------------
/Solucionario regional 2019/K.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <cstring>
 3 | #include <cmath>
 4 | #include <map>
 5 | #include <vector>
 6 | #include <string>
 7 | #include <algorithm>
 8 | #include <set>
 9 | #include <map>
10 | #include <unordered_map>
11 | using namespace std;
12 | string s;
13 | vector<long long>P;
14 | int main() {
15 | 	//freopen("in.txt","r",stdin);
16 | 	//freopen("out.txt","w",stdout);
17 | 	
18 | 	while(cin>>s){
19 | 		
20 | 		int id = 2;
21 | 		vector<long long>v;
22 | 		P.clear();
23 | 		
24 | 		for(int i = 0;i + 1 < s.size(); i++){
25 | 			if(s[i] != s[i+1])
26 | 				v.push_back(id+1);
27 | 			id += 2;
28 | 		}
29 | 		
30 | 		//(X-v[0])*(X-v[1]).....*(X-v[i])
31 | 		P.push_back(1);
32 | 		
33 | 		for(int i = 0; i < v.size(); i++){
34 | 			P.push_back(0);
35 | 			for(int j =P.size()-1; j >0 ;j--){
36 | 				P[j]-=P[j-1]*v[i];
37 | 			}
38 | 		}
39 | 		
40 | 		if( (v.size()%2 == 1 && s[0]=='H') || 
41 | 				(v.size()%2==0 && s[0]=='A')  ){
42 | 			for(int i = 0; i < P.size(); i++)
43 | 				P[i] = -P[i];
44 | 		}
45 | 		
46 | 		cout<<P.size() - 1<<endl;
47 | 		
48 | 		for(int i = 0; i < P.size() ;i++){
49 | 			cout<<P[i];
50 | 			if(i + 1 != P.size()){
51 | 				cout<<" ";
52 | 			}	
53 | 		}
54 | 		cout<<endl;
55 | 	}
56 | 		
57 | 	return 0;
58 | }
59 | 


--------------------------------------------------------------------------------
/solucionario regional 2017/E.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<cstring>
 3 | #include<cstdio>
 4 | #include<vector>
 5 | #include<cmath>
 6 | #include<sstream>
 7 | #include<algorithm>
 8 | #include<set>
 9 | #include<queue>
10 | #define MOD 1000000007LL
11 | using namespace std;
12 | string s;
13 | int k;
14 | int memo[1001][1001];
15 | 
16 | bool ispossible(int pos,int mod){
17 | 	if(pos==s.size())return (mod==0);
18 | 	if(memo[pos][mod]!=-1)return memo[pos][mod];
19 | 	int dev=0;
20 | 	
21 | 	if(s[pos]=='?'){
22 | 		for(int i=0;i<10;i++){
23 | 			if(pos==0 && i==0)continue;
24 | 			dev=dev|ispossible(pos+1,(mod*10+i)%k); 
25 | 		}
26 | 	}else{
27 | 		dev=dev|ispossible(pos+1,(mod*10+(s[pos]-'0'))%k);
28 | 	}
29 | 	
30 | 	memo[pos][mod]=dev;
31 | 	return dev;
32 | }
33 | 
34 | int main(){
35 | 	//freopen("in.txt","r",stdin);
36 | 	//freopen("out.txt","w",stdout);
37 | 	
38 | 	while(cin>>s>>k){
39 | 		memset(memo,-1,sizeof(memo));
40 | 			
41 | 		if(!ispossible(0,0)){
42 | 			cout<<"*"<<endl;
43 | 		}else{
44 | 			string dev="";
45 | 			int mod=0;
46 | 			
47 | 			for(int i=0;i<s.size();i++){
48 | 				if(s[i]=='?'){
49 | 					for(int j=0;j<10;j++){
50 | 						if(i==0 && j==0)continue;
51 | 						if(ispossible(i+1, (mod*10+j)%k )){
52 | 							mod=(mod*10+j)%k;
53 | 							dev+='0'+j;
54 | 							break;
55 | 						}
56 | 					}
57 | 				}else{
58 | 					dev+=s[i];
59 | 					mod=(mod*10+(s[i]-'0') )%k;
60 | 				}	
61 | 			}
62 | 				
63 | 			cout<<dev<<endl;
64 | 		}
65 | 		
66 | 	}
67 | 	
68 | 	return 0;
69 | }
70 | 


--------------------------------------------------------------------------------
/solucionario regional 2017/b.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<cstring>
 3 | #include<cstdio>
 4 | #include<vector>
 5 | #include<cmath>
 6 | #include<sstream>
 7 | #include<algorithm>
 8 | #include<set>
 9 | #include<queue>
10 | using namespace std;
11 | 
12 | vector<int>v;
13 | bool isvowel(char ch){
14 | 	if(ch=='a' || ch=='e' || ch=='i' || ch=='o' || ch=='u')
15 | 		return 1;
16 | 	return 0;
17 | }
18 | 
19 | int main(){
20 | 	//freopen("in.txt","r",stdin);
21 | 	//freopen("out.txt","w",stdout);
22 | 	string s;
23 | 	
24 | 	while(cin>>s){
25 | 		int countvowel=0;
26 | 		for(int i=0;i<s.size();i++)
27 | 			if(isvowel(s[i]))
28 | 				countvowel++;
29 | 		
30 | 		if(countvowel==0){
31 | 			//all consonant
32 | 			cout<<1<<endl;
33 | 			continue;
34 | 		}
35 | 		
36 | 		if(!isvowel(s[0]) ){
37 | 			// the first character have to be vowel
38 | 			cout<<0<<endl;
39 | 			continue;
40 | 		}
41 | 		
42 | 		if(countvowel==1){
43 | 			//sample    accccccccccc=  cacccccccccc= ccaccccccccc= cccaccccccccc ....
44 | 			cout<<s.size()<<endl;
45 | 			continue;
46 | 		}
47 | 		
48 | 		v.clear();
49 | 		// O( size(s) )
50 | 		for(int i=0;i<s.size();i++){
51 | 			if(isvowel(s[i])){
52 | 				//check the next vowel and count consonants
53 | 				int count=0;
54 | 				i++;
55 | 				
56 | 				while(i<s.size() && !isvowel(s[i])){
57 | 					count++;
58 | 					i++;
59 | 				}
60 | 					
61 | 				if(i==s.size())break;// if does not exist vowel
62 | 				v.push_back(count);
63 | 				i--;
64 | 			}
65 | 		}
66 | 		
67 | 		cout<<v[v.size()/2]+1<<endl;
68 | 		
69 | 	}
70 | 		
71 | 	return 0;
72 | }
73 | 
74 | 
75 | 


--------------------------------------------------------------------------------
/solucionario regional 2017/j.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<cstring>
 3 | #include<map>
 4 | #include<cstdio>
 5 | #include<vector>
 6 | #include<cmath>
 7 | #include<sstream>
 8 | #include<algorithm>
 9 | #include<set>
10 | #include<queue>
11 | using namespace std;
12 | int gcd[100005];
13 | 
14 | int main(){
15 | 	//freopen("in.txt","r",stdin);
16 | 	//freopen("out.txt","w",stdout);
17 | 	
18 | 	string s;
19 | 	
20 | 	while(cin>>s){
21 | 		int r=0,p=0;
22 | 		for(int i=0;i<s.size();i++)
23 | 			if(s[i]=='R'){
24 | 				r++;
25 | 			}else{
26 | 				p++;
27 | 			}
28 | 		
29 | 		if(p==0){
30 | 			cout<<s.size()-1<<endl;
31 | 			continue;
32 | 		}
33 | 		
34 | 		int n=s.size();
35 | 		vector<int>v;
36 | 		
37 | 		//O(sqrt(n), divisor of n
38 | 		for(int i=2;i*i<=n;i++){
39 | 			if(n%i==0){
40 | 				if(i*i==n){
41 | 					v.push_back(i);
42 | 					break;	
43 | 				}
44 | 				
45 | 				v.push_back(i);
46 | 				v.push_back(n/i);
47 | 			}
48 | 		}
49 | 		
50 | 		memset(gcd,0,sizeof(gcd));
51 | 		for(int i=2;i<n;i++)
52 | 			gcd[__gcd(i,n)]++;
53 | 		
54 | 		int count=0;
55 | 		
56 | 		for(int i=0;i<v.size();i++){
57 | 			//choose start [0-v[i]] 
58 | 			
59 | 			//O(n)
60 | 			bool yeah=0;
61 | 			for(int j=0;j<v[i];j++){
62 | 				bool ok=1;
63 | 				for(int k=j;k<n;k+=v[i]){
64 | 					if(s[k]=='P'){
65 | 						ok=0;
66 | 						break;
67 | 					}
68 | 				}
69 | 				
70 | 				if(ok){
71 | 					yeah=1;
72 | 					break;
73 | 				}
74 | 			}	
75 | 			
76 | 			if(yeah){
77 | 				count+=gcd[v[i]];
78 | 			}
79 | 		}
80 | 		
81 | 		cout<<count<<endl;
82 | 	}
83 | 	
84 | 	return 0;
85 | }
86 | 
87 | 
88 | 


--------------------------------------------------------------------------------
/solucionario regional 2015/a_greedy.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | #define all(v) v.begin(),v.end()
 3 | #define REP(i, a, b) \
 4 | for(int i = int(a); i < int(b); i++)
 5 | #define pb(v,e) v.push_back(e)
 6 | using namespace std;
 7 | typedef long long ll;
 8 | typedef vector<ll> vll;
 9 | typedef vector<int> vi;
10 | typedef vector<vi> vvi;
11 | typedef pair<int, int> ii;
12 | typedef vector<ii> vii;
13 | typedef set<int> si;
14 | typedef map<string, int> msi;
15 | ll stois(string s){
16 | 	istringstream in(s);
17 | 	ll x;
18 | 	in>>x;
19 | 	return x;
20 | }
21 | int f(string s){
22 | 	vi v(10,2);
23 | 	int ind;
24 | 	REP(i,0,s.size()){
25 | 		if(v[s[i]-'0']>0){
26 | 			v[s[i]-'0']--;
27 | 			ind=i;
28 | 			continue;
29 | 		}
30 | 		break;
31 | 	}
32 | 	return ind;
33 | }
34 | int main(){
35 | 	string s;
36 | 	while(cin>>s){
37 | 		int pos=f(s);
38 | 	//	cout<<"posicion: "<<pos<<endl;
39 | 		if(pos+1==s.size() || s.size()<=2){
40 | 			cout<<s<<endl;
41 | 			continue;
42 | 		}
43 | 		for(int i=pos+1;i>=0;i--){
44 | 			vi v(10,2);
45 | 			string cad;
46 | 			REP(j,0,i)v[s[j]-'0']--;
47 | 			for(int j=s[i]-'0'-1; j>=0;j--){
48 | 				if(v[j]>0){
49 | 					v[j]--;
50 | 					cad=s.substr(0,i)+string(1,j+'0');
51 | 					int cont=0;
52 | 					for(int k=9;k>=0;k--){
53 | 						for(int l=0;l<v[k];l++){
54 | 							if(cont==s.size()-i-1){
55 | 								break;
56 | 							}
57 | 							cad+=string(1,'0'+k);
58 | 							cont++;
59 | 						}
60 | 					}
61 | 					break;
62 | 				}
63 | 			}
64 | 			if(cad.size()>0){
65 | 				cout<<stois(cad)<<endl;
66 | 				break;
67 | 			}
68 | 		}
69 | 	}
70 | 	return 0;
71 | }
72 | 
73 | 


--------------------------------------------------------------------------------
/solucionario regional 2013/c.cpp:
--------------------------------------------------------------------------------
 1 | #include <vector>
 2 | #include <list>
 3 | #include <map>
 4 | #include <set>
 5 | #include <queue>
 6 | #include <deque>
 7 | #include <stack>
 8 | #include <bitset>
 9 | #include <algorithm>
10 | #include <functional>
11 | #include <numeric>
12 | #include <utility>
13 | #include <sstream>
14 | #include <iostream>
15 | #include <iomanip>
16 | #include <cstdio>
17 | #include <cmath>
18 | #include <cstdlib>
19 | #include <ctime>
20 | #include <string.h>
21 | #include <stdio.h>
22 | #define all(v) (v).begin(),(v).end()
23 | #define rall(v) (v).rbegin(),(v).rend()
24 | using namespace std;  // H A M L E T
25 | 
26 | int target[66];
27 | long long memo[66][2][66];
28 | 
29 | long long dp(int pos,bool menor,int sum){
30 |     if(pos==-1)return sum;
31 |     if(memo[pos][menor][sum]!=-1)return memo[pos][menor][sum];
32 |     long long dev=0;
33 |     
34 |     if(menor){
35 |         dev+=dp(pos-1,menor,sum+1)+dp(pos-1,menor,sum);    
36 |     }else{
37 |         if(target[pos]==0){
38 |             dev+=dp(pos-1,menor,sum);    
39 |         }else{
40 |             dev+=dp(pos-1,1,sum)+dp(pos-1,0,sum+1);    
41 |         }    
42 |     }
43 |     
44 |     memo[pos][menor][sum]=dev;
45 |     return dev;
46 | }
47 | 
48 | long long f(long long t){
49 |     int cont=0;
50 |     while(t!=0){
51 |         target[cont++]=t%2;
52 |         t/=2;    
53 |     }
54 |     memset(memo,-1,sizeof(memo));
55 |     return dp(cont-1,0,0);
56 | }
57 | 
58 | int main(){
59 |     
60 |     long long a,b;
61 |     while(cin>>a>>b){
62 |         cout<<f(b)-f(a-1)<<endl;    
63 |     }
64 |     
65 |     
66 |     return 0;
67 | }
68 | 


--------------------------------------------------------------------------------
/Solucionario regional 2019/I.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <cstring>
 3 | #include <cmath>
 4 | #include <map>
 5 | #include <vector>
 6 | #include <string>
 7 | #include <algorithm>
 8 | #include <set>
 9 | #include <map>
10 | #include <unordered_map>
11 | using namespace std;
12 | vector<int>v[2004];
13 | int N, L;
14 | set<int> uniq;
15 | bool visited[2004];
16 | int memo[2004];
17 | 
18 | void dfs(int list){
19 | 	visited[list] = 1;
20 | 	
21 | 	for(int i = 0;i <v[list].size();i++){
22 | 		int id = v[list][i];
23 | 		//its a list
24 | 		if( id <= L){
25 | 			if(!visited[id])
26 | 				dfs(id);		
27 | 		}else{
28 | 			//its a client
29 | 			uniq.insert(id);
30 | 		}
31 | 	}
32 | 	
33 | }
34 | 
35 | int dp(int list){
36 | 	
37 | 	if(memo[list] != -1)return memo[list];
38 | 	int ans = 0;
39 | 	
40 | 	for(int i = 0;i < v[list].size(); i++){
41 | 		int id = v[list][i];
42 | 		
43 | 		if( id <= L){
44 | 			ans = (ans + dp(id) )%1000000007;
45 | 		}else{
46 | 			ans = (ans +1 )%1000000007;
47 | 		}		
48 | 	}
49 | 	
50 | 	memo[list] = ans;
51 | 	return ans;
52 | }
53 | 
54 | int main() {
55 | 	
56 | 	while( scanf("%d %d",&N,&L) == 2){
57 | 		for(int i = 0; i <= N;i++)if(v[i].size() > 0)v[i].clear();
58 | 		
59 | 		for(int i = 0;i < L; i++){
60 | 			int k; scanf("%d",&k);
61 | 			for(int j = 0; j < k ;j++ ){
62 | 				int aux; scanf("%d",&aux);
63 | 				v[i + 1].push_back(aux);
64 | 			}
65 | 		}	
66 | 		
67 | 		uniq.clear();
68 | 		memset(visited,0,sizeof(visited));
69 | 		dfs(1);
70 | 		
71 | 		memset(memo,-1,sizeof(memo));
72 | 		cout<<dp(1)<<" "<<uniq.size()<<endl;
73 | 	}
74 | 	
75 | 		
76 | 	return 0;
77 | }
78 | 


--------------------------------------------------------------------------------
/solucionario regional 2013/I.cpp:
--------------------------------------------------------------------------------
 1 | #include <vector>
 2 | #include <list>
 3 | #include <map>
 4 | #include <set>
 5 | #include <queue>
 6 | #include <deque>
 7 | #include <stack>
 8 | #include <bitset>
 9 | #include <algorithm>
10 | #include <functional>
11 | #include <numeric>
12 | #include <utility>
13 | #include <sstream>
14 | #include <iostream>
15 | #include <assert.h>
16 | #include <iomanip>
17 | #include <cstdio>
18 | #include <cmath>
19 | #include <cstdlib>
20 | #include <ctime>
21 | #include <string.h>
22 | #include <stdio.h>
23 | #define all(v) (v).begin(),(v).end()
24 | #define rall(v) (v).rbegin(),(v).rend()
25 | using namespace std;  // H A M L E T
26 | 
27 | int main(){
28 |     
29 |     int x[52];
30 |     int n;
31 |     
32 |     while(cin>>n){
33 |         memset(x,0,sizeof(x));
34 |         int mayor=0;
35 |         
36 |         for(int i=0;i<n;i++){
37 |             int aux;
38 |             scanf("%d",&aux);
39 |             x[aux]++;
40 |             mayor=max(aux,mayor);    
41 |         }
42 |         
43 |         
44 |         long long maxi=1;
45 |         vector<long long>dev;
46 |         
47 |         for(int i=0;i<x[mayor]/2;i++)dev.push_back(2);
48 |         
49 |         for(int i=mayor-1;i>0;i--){
50 |             for(int j=0;j<x[i];j++)
51 |                 dev.push_back(maxi);
52 |             
53 |             vector<long long>aux;
54 |             for(int j=0;j<dev.size();j+=2){
55 |                 aux.push_back(dev[j]+dev[j+1]);
56 |                 maxi=max(maxi,dev[j]+dev[j+1]);
57 |             }
58 |             
59 |             dev=aux;    
60 |         }
61 |         
62 |         cout<<dev[0]<<endl;
63 |     }
64 |     
65 |     return 0;
66 | }
67 | 


--------------------------------------------------------------------------------
/Solucionario regional 2019/L.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <cstring>
 3 | #include <cmath>
 4 | #include <map>
 5 | #include <vector>
 6 | #include <string>
 7 | #include <algorithm>
 8 | #include <set>
 9 | #include <map>
10 | #include <unordered_map>
11 | using namespace std;
12 | int c[1002][1002];
13 | 
14 | 
15 | int main() {
16 | 	
17 | 	int R, C;	
18 | 	while( scanf("%d %d",&R, &C) == 2){
19 | 		char s[1002];
20 | 		for(int i = 0; i < R; i++){
21 | 			scanf("%s",s);	
22 | 			
23 | 			c[i][C-1] = 1;
24 | 			for(int j = C-2; j >=0 ;j--){
25 | 				if( s[j] == s[j+1] ){
26 | 					c[i][j] = 1 + c[i][j+1];
27 | 				}else{
28 | 					c[i][j] = 1;
29 | 				}
30 | 			}
31 | 		}
32 | 		
33 | 		int ans = 0;
34 | 		
35 | 		for(int j = 0; j < C; j++){
36 | 			vector<int> v(R);
37 | 			for(int i = 0;i < R;i++)
38 | 				v[i] = c[i][j]; 
39 | 			
40 | 			int right[R];
41 |         	right[R - 1] = R;
42 |         	
43 | 			int left[R];
44 |         	left[0]=-1;
45 |         
46 | 	        for(int i = R - 2;i >= 0;i--){
47 |     	        int idx = i + 1;
48 |         	    while( idx != R && v[idx] >= v[i])
49 |             	    idx = right[idx];   
50 |             	right[i] = idx;
51 |         	}
52 |         
53 | 	        for(int i = 1; i < R;i++){
54 |     	        int idx = i - 1;
55 |         	    while( idx != -1 && v[idx] >= v[i])
56 |             	    idx = left[idx];
57 |             	left[i] = idx;
58 |         	}
59 | 			
60 | 			
61 | 	        for(int  i= 0;i < R;i++){
62 | 	        	int size = right[i] - left[i] - 1;
63 | 	        	ans = max(ans, min(size, v[i]) );
64 | 			}
65 | 		}
66 | 		
67 | 		cout<<ans*ans<<endl;	
68 | 	}		
69 | 	return 0;
70 | }
71 | 


--------------------------------------------------------------------------------
/solucionario regional 2013/d.cpp:
--------------------------------------------------------------------------------
 1 | #include <vector>
 2 | #include <list>
 3 | #include <map>
 4 | #include <set>
 5 | #include <queue>
 6 | #include <deque>
 7 | #include <stack>
 8 | #include <bitset>
 9 | #include <algorithm>
10 | #include <functional>
11 | #include <numeric>
12 | #include <utility>
13 | #include <sstream>
14 | #include <iostream>
15 | #include <iomanip>
16 | #include <cstdio>
17 | #include <cmath>
18 | #include <cstdlib>
19 | #include <ctime>
20 | #include <string.h>
21 | #include <stdio.h>
22 | #define all(v) (v).begin(),(v).end()
23 | #define rall(v) (v).rbegin(),(v).rend()
24 | using namespace std;  // H A M L E T
25 | vector<int> v[100001];
26 | int memo[1001][1001];
27 | 
28 | int dp(int x,int y){
29 |     if(x==y)return 0;
30 |     if(x==1)return 1;
31 |     if(memo[x][y]!=-1)return memo[x][y];
32 |     bool dev=0;
33 |     
34 |     for(int i=v[y].size()-1;i>=0;i--){
35 |         if(dp(min(x,v[y][i]),max(x,v[y][i])) ){
36 |             dev=1;
37 |             break;    
38 |         }    
39 |     }
40 |     
41 |     memo[x][y]=dev;
42 |     return dev;
43 | }
44 | 
45 | int main(){
46 |     
47 |     int C,P;
48 |     
49 |     while(cin>>C>>P){
50 |         for(int i=0;i<100001;i++)
51 |             if(v[i].size()>0)v[i].clear();
52 |         
53 |         for(int i=0;i<P;i++){
54 |             int a,b;
55 |             scanf("%d%d",&a,&b);
56 |             v[max(a,b)].push_back(min(a,b));
57 |         }
58 |         
59 |         int dev=C-1;
60 |         memset(memo,-1,sizeof(memo));
61 |         
62 |         for(int i=2;i<=C;i++)
63 |             for(int j=i+1;j<=C;j++){
64 |                 dev+=dp(i,j);    
65 |             }
66 |             
67 |         cout<<dev<<endl;
68 |     }
69 |     
70 |     return 0;
71 | }
72 | 


--------------------------------------------------------------------------------
/solucionario regional 2013/f.cpp:
--------------------------------------------------------------------------------
 1 | #include <vector>
 2 | #include <list>
 3 | #include <map>
 4 | #include <set>
 5 | #include <queue>
 6 | #include <deque>
 7 | #include <stack>
 8 | #include <bitset>
 9 | #include <algorithm>
10 | #include <functional>
11 | #include <numeric>
12 | #include <utility>
13 | #include <sstream>
14 | #include <iostream>
15 | #include <iomanip>
16 | #include <cstdio>
17 | #include <cmath>
18 | #include <cstdlib>
19 | #include <ctime>
20 | #include <string.h>
21 | #include <stdio.h>
22 | #define all(v) (v).begin(),(v).end()
23 | #define rall(v) (v).rbegin(),(v).rend()
24 | using namespace std;  // H A M L E T
25 | 
26 | int main(){
27 |     
28 |     int n,g;
29 |     while(cin>>n>>g){
30 |         int win=0;
31 |         vector<int>v;
32 |         
33 |         for(int i=0;i<n;i++){
34 |             int a,b;
35 |             cin>>a>>b;
36 |             if(a>b)win+=3;
37 |             else{
38 |                 if(a==b)win++;
39 |                 v.push_back(b-a);   
40 |             }   
41 |         }
42 |         
43 |         sort(v.begin(),v.end());
44 |         int dev=win;
45 |         int sum=0;
46 |         
47 |         for(int i=0;i<v.size();i++){
48 |             if(v[i]==0){
49 |                 if(g>0){
50 |                     g--;       
51 |                     dev+=2;
52 |                 }
53 |             }
54 |             
55 |             
56 |             if(v[i]>0 && g>=v[i]+1){
57 |                 g-=v[i]+1;
58 |                 dev+=3;    
59 |             }else{
60 |                 if(v[i]>0&& g==v[i]){
61 |                     g=0;
62 |                     dev++;    
63 |                 }    
64 |             }    
65 |         }
66 |         
67 |         cout<<dev<<endl;
68 |     }
69 |     
70 |     return 0;
71 | }
72 | 


--------------------------------------------------------------------------------
/solucionario regional 2017/C.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<cstring>
 3 | #include<cstdio>
 4 | #include<vector>
 5 | #include<cmath>
 6 | #include<sstream>
 7 | #include<algorithm>
 8 | #include<set>
 9 | #include<queue>
10 | #define MOD 1000000007LL
11 | using namespace std;
12 | 
13 | int main(){
14 | 	//freopen("in.txt","r",stdin);
15 | 	//freopen("out.txt","w",stdout);
16 | 	
17 | 	int k,n;
18 | 	
19 | 	while(cin>>k>>n){
20 | 		vector<int>f(k+1,0);
21 | 		
22 | 		for(int i=0;i<n;i++){
23 | 			int aux;
24 | 			scanf("%d",&aux);
25 | 			f[aux]++;
26 | 		}
27 | 		
28 | 		if(n%k==(k-1)){
29 | 			int num=0;
30 | 			for(int i=1;i<=k;i++)
31 | 				if( (n)/k==f[i])
32 | 					num=i;
33 | 			f[num]++;
34 | 			bool ok=1;
35 | 			for(int i=2;i<=k;i++)
36 | 				if(f[i]!=f[i-1])ok=0;
37 | 				
38 | 			if(ok)
39 | 				cout<<"+"<<num<<endl;
40 | 			else
41 | 				cout<<"*"<<endl;
42 | 		}else if(n%k==1){
43 | 			int num=0;
44 | 			for(int i=1;i<=k;i++)
45 | 				if( (n/k)+1==f[i]){
46 | 					num=i;
47 | 				}
48 | 			
49 | 			f[num]--;
50 | 			bool ok=1;
51 | 			for(int i=2;i<=k;i++)
52 | 				if(f[i]!=f[i-1])ok=0;
53 | 				
54 | 			if(ok)
55 | 				cout<<"-"<<num<<endl;
56 | 			else
57 | 				cout<<"*"<<endl;
58 | 			
59 | 		}else if(n%k==0){
60 | 			
61 | 			int num1=0;int num2=0;
62 | 			for(int i=1;i<=k;i++){
63 | 				if( (n/k)+1==f[i]){
64 | 					num1=i;
65 | 				}
66 | 				
67 | 				if( (n/k)-1==f[i]){
68 | 					num2=i;
69 | 				}
70 | 				
71 | 			}
72 | 			
73 | 			f[num1]--;f[num2]++;
74 | 			bool ok=1;
75 | 			for(int i=2;i<=k;i++)
76 | 				if(f[i]!=f[i-1])ok=0;
77 | 				
78 | 			if(ok)
79 | 				cout<<"-"<<num1<<" +"<<num2<<endl;
80 | 			else
81 | 				cout<<"*"<<endl;
82 | 			
83 | 			
84 | 		}else{
85 | 			cout<<"*"<<endl;
86 | 		}
87 | 		
88 | 	}
89 | 	
90 | 	
91 | 	return 0;
92 | }
93 | 


--------------------------------------------------------------------------------
/solucionario regional 2012/c.cpp:
--------------------------------------------------------------------------------
 1 | #include <ctime>
 2 | #include <numeric>
 3 | #include <functional>
 4 | #include <iostream>
 5 | #include <vector>
 6 | #include <algorithm>
 7 | #include <bitset>
 8 | #include <string>
 9 | #include <cstring>
10 | #include <climits>
11 | #include <cmath>
12 | #include <cctype>
13 | #include <sstream>
14 | #include <map>
15 | #include <set>
16 | #include <cstdio>
17 | #include <queue>
18 | using namespace std;
19 | int n;
20 | char s[100000][81];
21 | int trie[1000000][26];
22 | int mask[1000000];
23 | bool terminal[1000000];
24 | int node;
25 | 
26 | void add(char *s){
27 |     
28 |     int p=0;
29 |     
30 |     for(int i=0;i<strlen(s);i++){
31 |         mask[p]|=(1<<(s[i]-'a'));
32 |         if(trie[p][s[i]-'a']==0){
33 |             p=trie[p][s[i]-'a']=++node;    
34 |         }else{
35 |             p=trie[p][s[i]-'a'];
36 |         }    
37 |     }
38 |     
39 |     terminal[p]=1;
40 | }
41 | 
42 | int main(){
43 |     //freopen("in.txt","r",stdin);
44 |     //freopen("out.txt","w",stdout);
45 |     
46 |     
47 |     while(cin>>n){
48 |         
49 |         memset(trie,0,sizeof(trie));
50 |         memset(mask,0,sizeof(mask));
51 |         memset(terminal,0,sizeof(terminal));
52 |         
53 |         
54 |         node=0;
55 |         for(int i=0;i<n;i++){
56 |             scanf("%s",s[i]);
57 |             add(s[i]);
58 |         }
59 |         
60 |         int cont=0;
61 |         
62 |         for(int i=0;i<n;i++){
63 |             int p=trie[0][s[i][0]-'a'];
64 |             cont++;
65 |             for(int j=1;j<strlen(s[i]);j++){
66 |                 if(__builtin_popcount(mask[p])>1 || terminal[p] ){
67 |                     cont++;    
68 |                 }
69 |                 p=trie[p][s[i][j]-'a'];
70 |             }
71 |         }
72 |         
73 |         printf("%.2lf\n",cont/(n+0.0));
74 |     }
75 |      
76 |     return 0;
77 | }
78 | 


--------------------------------------------------------------------------------
/solucionario regional 2016/c.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<cstring>
 3 | #include<cstdio>
 4 | #include<vector>
 5 | #include<numeric>
 6 | #include<cmath>
 7 | #include<sstream>
 8 | #include<algorithm>
 9 | #include<set>
10 | #include<queue>
11 | #include<map>
12 | #define MOD 1000000007
13 | using namespace std;
14 | int C[1001][1001];
15 | 
16 | void combinatoria(int n){
17 | 	C[0][0]=1;
18 | 	for(int i=1;i<=n;i++){
19 | 		C[i][0]=1;
20 | 		C[i][i]=1;
21 | 		for(int j=1;j<i;j++){
22 | 			C[i][j]=(C[i-1][j]+C[i-1][j-1])%MOD;	
23 | 		}
24 | 	}
25 | }
26 | 
27 | int main(){
28 | 	//freopen("in.txt","r",stdin);
29 | 	//freopen("out.txt","w",stdout);
30 | 	
31 | 	long long x[1001],y[1001];
32 | 	int n;
33 | 	combinatoria(1000);
34 | 	
35 | 	while(scanf("%d",&n)==1){
36 | 		map<pair<long long,long long>,int >m;
37 | 		set<pair<long long,long long> >S;
38 | 	
39 | 		int a,b;
40 | 		for(int i=0;i<n;i++){
41 | 			scanf("%d %d",&a,&b);
42 | 			x[i]=2*a;
43 | 			y[i]=2*b;
44 | 			S.insert(make_pair(x[i],y[i]));
45 | 		}	
46 | 		
47 | 		for(int i=0;i<n;i++)
48 | 			for(int j=i+1;j<n;j++){
49 | 				pair<long long,long long>P= make_pair( (x[i]+x[j])/2, (y[i]+y[j])/2);
50 | 				m[P]++;
51 | 			}
52 | 		
53 | 		map< pair<long long,long long>,int>::iterator it=m.begin();
54 | 		long long ans[n+1];
55 | 		memset(ans,0,sizeof(ans));
56 | 		
57 | 		while(it!=m.end()){
58 | 			pair<long long,long long>P=it->first;
59 | 			int freq=it->second;
60 | 			
61 | 			bool ok=0;
62 | 			if(S.find(P)!=S.end())ok=1;
63 | 			
64 | 			if(freq>=1){
65 | 				for(int i=1;i<=freq;i++){
66 | 					ans[2*i]=(ans[2*i]+ C[freq][i] )%MOD;
67 | 					if(ok)
68 | 						ans[2*i+1]= (ans[2*i+1]+C[freq][i])%MOD;
69 | 				}
70 | 			}
71 | 							
72 | 			it++;
73 | 		}		
74 | 		
75 | 		ans[1]=n;
76 | 		ans[2]=(n*(n-1))/2;
77 | 		
78 | 		cout<<ans[1];
79 | 		for(int i=2;i<=n;i++)
80 | 			cout<<" "<<ans[i];
81 | 		cout<<endl;
82 | 	}
83 | 	
84 | 	
85 |     return 0;
86 | }
87 | 


--------------------------------------------------------------------------------
/solucionario regional 2015/c.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<cstring>
 3 | #include<cstdio>
 4 | #include<algorithm>
 5 | #include<sstream>
 6 | #include<set>
 7 | #include<cstring>
 8 | #include<vector>
 9 | #include<map>
10 | #include<cassert>
11 | #include<cmath>
12 | #include<queue>
13 | using namespace std; 
14 | int n;
15 | long long x[100001],y[100001];
16 | long long ac[200005];
17 | long long area;
18 | 
19 | long long f(int a,int b){
20 |     long long dev=ac[b-1];
21 |     if(a>0)dev-=ac[a-1];
22 |     long long A1=abs( dev+(x[b%n]*y[a%n]-x[a%n]*y[b%n])  );
23 |     long long A2= area-A1;
24 |     return max(A1,A2);
25 | }
26 | 
27 | int main(){
28 | 
29 |     
30 |     while(cin>>n){
31 |         int a,b;
32 |         for(int i=0;i<n;i++){
33 |             scanf("%d %d",&a,&b);
34 |             x[i]=a;
35 |             y[i]=b;
36 |         }
37 |         
38 |         long long sum=0;
39 |         area=0;
40 |         for(int i=0;i<n;i++)
41 |             area+=(x[i%n]*y[(i+1)%n]- x[(i+1)%n]*y[i%n] );
42 |             
43 |         area=abs(area);
44 | 
45 |         for(int i=0;i<2*n;i++){
46 |             ac[i]= (x[i%n]*y[(i+1)%n]- x[(i+1)%n]*y[i%n] );
47 |             if(i>0)ac[i]+=ac[i-1];
48 |         }
49 |         
50 |         long long maxi=0;
51 | 
52 |         for(int i=0;i<n;i++){
53 |             int lo=i;
54 |             int hi=i+n-1;
55 |             for(int j=0;j<35;j++){
56 |                 int me1=(2*lo+hi)/3;
57 |                 int me2=(lo+2*hi)/3;
58 |                 if( f(i,me1)<f(i,me2) ){
59 |                     hi=me2;
60 |                 }else{
61 |                     lo=me1;
62 |                 }
63 |             }
64 |             
65 |             long long mini=1LL<<60;
66 |             for(int j=lo;j<=hi;j++)
67 |                 mini=min(mini,f(i,j));
68 |             
69 |             maxi=max(mini,maxi);
70 |         }
71 |         cout<<maxi<<" "<<(area-maxi)<<endl;
72 |     }
73 |     
74 |     return 0;
75 | }
76 | 


--------------------------------------------------------------------------------
/solucionario regional 2016/i.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<cstring>
 3 | #include<cstdio>
 4 | #include<vector>
 5 | #include<cmath>
 6 | #include<sstream>
 7 | #include<algorithm>
 8 | #include<set>
 9 | #include<cassert>
10 | #include<queue>
11 | using namespace std;
12 | //http://codeforces.com/blog/entry/8219
13 | int n,b,c;
14 | long long h[6003];
15 | long long dp[6003][2];
16 | long long F[6003];
17 | long long C[6003];
18 | long long G[6003][6003];
19 | 
20 | void compute(int k,int L,int R,int optL,int optR){
21 | 	if(L>R)return ;
22 | 	int mid= (L+R)/2;
23 | 	dp[mid][k&1]=1LL<<62;
24 | 	int best=-1;
25 | 	int fin=min(optR,mid-1);
26 | 	
27 | 	for(int j=optL;j<= fin;j++){
28 | 		if(mid==n){
29 | 			long long val=dp[j][(k-1)&1]+G[j+1][n];
30 | 			if(dp[mid][k&1]> val){
31 | 				dp[mid][k&1]=val;
32 | 				best=j;
33 | 			}	
34 | 		}else{
35 | 			long long val=dp[j][(k-1)&1]+G[j+1][mid-1];
36 | 			if(dp[mid][k&1]> val){
37 | 				dp[mid][k&1]=val;
38 | 				best=j;
39 | 			}
40 | 		}			
41 | 	}
42 | 
43 | 	compute(k,L,mid-1,optL,best);
44 | 	compute(k,mid+1,R,best,optR);
45 | }
46 | 
47 | int main(){
48 | 	//freopen("in.txt","r",stdin);
49 | 	//freopen("out.txt","w",stdout);
50 | 
51 | 	// Solucion en O(n^2*logn)
52 | 	while(scanf("%d %d %d",&n,&b,&c)==3){
53 | 		//cout<<n<<" "<<b<<" "<<c<<endl;
54 | 		F[0]=0;
55 | 		C[0]=0;
56 | 		
57 | 		memset(G,0,sizeof(G));
58 | 		
59 | 		
60 | 		for(int i=0;i<n;i++){
61 | 			int aux;
62 | 			scanf("%d",&aux);
63 | 			h[i]=aux;
64 | 			F[i+1]=F[i]+aux;
65 | 			C[i+1]=C[i]+(long long)aux*i;
66 | 		}
67 | 		
68 | 		for(int i=n-1;i>=0;i--){
69 | 			G[i][i]=h[i];
70 | 			for(int j=i+1;j<n;j++){
71 | 				G[i][j]=F[j+1]-F[i]+G[i+1][j-1];
72 | 			}
73 | 		}
74 | 			
75 | 		memset(dp,0,sizeof(dp));
76 | 		
77 | 		for(int i=0;i<n;i++)
78 | 			dp[i][0]=i*F[i]-C[i];
79 | 		
80 | 		for(int i=n-1;i>=0;i--)
81 | 			G[i][n]= (F[n]-F[i])+G[i+1][n];
82 | 
83 | 	
84 | 		for(int k=1;k<=n;k++){
85 | 			compute(k, 0, n, k-1,n-1 );
86 | 			long long mini=dp[n][k&1]*c+(long long)k*b;
87 | 			
88 | 			cout<<mini;
89 | 			if(k!=n)cout<<" ";
90 | 		}
91 | 		
92 | 		cout<<endl;
93 | 	}
94 | 
95 |     return 0;
96 | }
97 | 
98 | 


--------------------------------------------------------------------------------
/solucionario regional 2012/E.cpp:
--------------------------------------------------------------------------------
 1 | #include <ctime>
 2 | #include <numeric>
 3 | #include <functional>
 4 | #include <iostream>
 5 | #include <vector>
 6 | #include <algorithm>
 7 | #include <bitset>
 8 | #include <string>
 9 | #include <cstring>
10 | #include <climits>
11 | #include <cmath>
12 | #include <cctype>
13 | #include <sstream>
14 | #include <map>
15 | #include <set>
16 | #include <cstdio>
17 | #include <queue>
18 | using namespace std;
19 | double a1[9],a2[9];
20 | double b1[9],b2[9];
21 | int w,d,a,k;
22 | 
23 | inline double f(double x,double me){
24 |     double num1=0,den1=0,num2=0,den2=0;
25 |     
26 |     for(int i=k;i>=0;i--){
27 |         num1=num1*x+a1[i];
28 |         den1=den1*x+b1[i];
29 |         num2=num2*x+a2[i];
30 |         den2=den2*x+b2[i];
31 |     }
32 |     
33 |     double image1=num1/den1;
34 |     double image2=num2/den2;
35 |     
36 |     if(me>image1)return 0;
37 |     
38 |     if(me>image2)return image1-me;
39 |     return image1-image2;
40 | }
41 | 
42 | int main(){
43 |     
44 |     //freopen("in.txt","r",stdin);
45 |     //freopen("out.txt","w",stdout);
46 |     
47 |     int n;
48 |     
49 |     while(scanf("%d %d %d %d",&w,&d,&a,&k)==4){
50 |         
51 |         for(int i=0;i<k+1;i++)
52 |             scanf("%lf",&a1[i]);    
53 |         
54 |         for(int i=0;i<k+1;i++)
55 |             scanf("%lf",&b1[i]);    
56 |         
57 |         for(int i=0;i<k+1;i++)
58 |             scanf("%lf",&a2[i]);    
59 |         
60 |         for(int i=0;i<k+1;i++)
61 |             scanf("%lf",&b2[i]);    
62 |         
63 |         double low=-d;
64 |         double hi=0;
65 |             
66 |         for(int ii=0;ii<22;ii++){
67 |             double me=(low+hi)/2;
68 |             double dif=1e-3;
69 |             double ini=0;
70 |             double sum=0;
71 |             
72 |             for(int i=0;i<1000*w;i++,ini+=dif)
73 |                 sum+=(f(ini,me)+4*f(ini+dif/2,me)+f(ini+dif,me) )/6.0;
74 |             
75 |                           
76 |             if(sum*dif <a ){
77 |                 hi=me;
78 |             }else{
79 |                 low=me;    
80 |             }
81 |         }
82 |         
83 |         printf("%.5f\n",-low);
84 |     }
85 |     
86 |     return 0;
87 | }
88 | 


--------------------------------------------------------------------------------
/solucionario regional 2015/a_dinamica.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<cstring>
 3 | #include<cstdio>
 4 | #include<algorithm>
 5 | #include<sstream>
 6 | #include<set>
 7 | #include<cstring>
 8 | #include<vector>
 9 | #include<map>
10 | #include<cassert>
11 | #include<cmath>
12 | #include<queue>
13 | using namespace std;
14 | string s;
15 | int pot3[21];long long pot10[21];
16 | long long memo[20][2][100001];
17 | 
18 | long long dp(int pos,bool menor,int val){
19 |     if(pos==-1)return 0;
20 |     if(memo[pos][menor][val]!=-1)return memo[pos][menor][val];
21 | 
22 |     int aux=val;
23 |     int c[10];
24 |     for(int i=0;i<10;i++){
25 |         c[i]=aux%3;
26 |         aux/=3;
27 |     }
28 | 
29 |     long long dev=-1LL<<60;
30 |     if(menor){//el numero que estoy formando ya es menor asi que le puedo meter cualquier digito
31 |         for(int i=0;i<=9;i++)
32 |             if(c[i]<2)
33 |                 dev=max(dev, i*pot10[pos] +  dp(pos-1,menor,val+pot3[i]));
34 |     }else{
35 |         //Si pongo un digito menor al digito  en analisis entonces ya estare formando un numero menor bool menor=1
36 |         for(int i=0;i<(s[pos]-'0');i++)
37 |             if(c[i]<2)
38 |                 dev=max(dev, i*pot10[pos] +  dp(pos-1,1,val+pot3[i]));
39 |         //colocamos el mismo digito que el de analisis S  bool menor=0 se mantiene.
40 |         if(c[s[pos]-'0']<2)
41 |             dev=max(dev, (s[pos]-'0')*pot10[pos] + dp(pos-1,menor,val+pot3[s[pos]-'0']));
42 |     }
43 | 
44 |     memo[pos][menor][val]=dev;
45 |     return dev;
46 | }
47 | 
48 | int main(){
49 | 
50 |     pot3[0]=pot10[0]=1;
51 |     for(int i=1;i<=10;i++)pot3[i]=pot3[i-1]*3;
52 |     for(int i=1;i<=18;i++)pot10[i]=pot10[i-1]*10;
53 | 
54 |     while(cin>>s){
55 |         reverse(s.begin(),s.end());
56 |         //cout<<s<<endl;
57 |         int t=s.size();
58 | 
59 |         memset(memo,-1,sizeof(memo));
60 |         long long dev=1;
61 |         //voy desde la posicion mas significativa
62 |         for(int i=1;i<=(s[t-1]-'0');i++)
63 |             if(i==(s[t-1]-'0'))
64 |                 dev=max(dev, i*pot10[t-1]  +dp(t-2,0,pot3[i]));
65 |             else
66 |                 dev=max(dev, i*pot10[t-1]  +dp(t-2,1,pot3[i]));
67 | 
68 |         if(t>=2)
69 |             dev=max(dev,  9*pot10[t-2]  +dp(t-3,1,pot3[9])  )   ;
70 | 
71 |         cout<<dev<<endl;
72 |     }
73 | 
74 |     return 0;
75 | }
76 | 
77 | 
78 | 


--------------------------------------------------------------------------------
/solucionario regional 2017/g.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<cstring>
 3 | #include<cstdio>
 4 | #include<vector>
 5 | #include<cmath>
 6 | #include<sstream>
 7 | #include<algorithm>
 8 | #include<set>
 9 | #include<queue>
10 | #define MOD 1000000007LL
11 | using namespace std;
12 | int izq[100005];
13 | int der[100005];
14 | int op[100005];
15 | long long memo[100005][2][2];
16 | 
17 | // how many ways to get correct value u in the gate node but the output is v
18 | long long dp(int node,int u,int v){
19 | 	
20 | 	if(memo[node][u][v]!=-1)return memo[node][u][v];
21 | 	// 0 0 |1
22 | 	// 0 1 |1
23 | 	// 1 0 |1
24 | 	// 1 1 |0	
25 | 	long long a=(izq[node]==-1?1:dp(izq[node],0,0));
26 | 	long long b=(izq[node]==-1?0:dp(izq[node],0,1));
27 | 	long long c=(izq[node]==-1?0:dp(izq[node],1,0));
28 | 	long long d=(izq[node]==-1?1:dp(izq[node],1,1));
29 | 		
30 | 	long long e=(der[node]==-1?1:dp(der[node],0,0));
31 | 	long long f=(der[node]==-1?0:dp(der[node],0,1));
32 | 	long long g=(der[node]==-1?0:dp(der[node],1,0));
33 | 	long long h=(der[node]==-1?1:dp(der[node],1,1));
34 | 	
35 | 	long long dev=0;
36 | 	
37 | 	if(op[node]==-1){
38 | 		if(u==0 && v==0)dev=(d*h)%MOD;
39 | 		if(u==0 && v==1)dev=(c*h+d*g+c*g)%MOD;
40 | 		if(u==1 && v==0)dev=(b*f+b*h+d*f)%MOD;
41 | 		if(u==1 && v==1)dev= (a*e+a*f+a*g+a*h+b*e+b*g+c*e+c*f+d*e)%MOD;
42 | 	}
43 | 	
44 | 	if(op[node]==1){
45 | 		if(u==0 && v==1)dev=( (c+d)*(g+h))%MOD;
46 | 		if(u==1 && v==1)dev= (((  ((a+b+c+d)%MOD)*((e+f+g+h)%MOD) - (c+d)*(g+h)%MOD    ) %MOD)+MOD)%MOD;
47 | 	}
48 | 	
49 | 	if(op[node]==0){
50 | 		if(u==0 && v==0)dev=( (c+d)*(g+h))%MOD;
51 | 		if(u==1 && v==0)dev= (((  ((a+b+c+d)%MOD)*((e+f+g+h)%MOD) - (c+d)*(g+h)%MOD    ) %MOD)+MOD)%MOD;
52 | 	}
53 | 	
54 | 	memo[node][u][v]=dev;
55 | 	return dev;
56 | }
57 | 
58 | 
59 | int main(){
60 | 	//freopen("in.txt","r",stdin);
61 | 	//freopen("out.txt","w",stdout);
62 | 	
63 | 	int n;
64 | 	
65 | 	while(cin>>n){
66 | 		memset(izq,-1,sizeof(izq));
67 | 		memset(der,-1,sizeof(der));
68 | 		
69 | 		for(int i=1;i<=n;i++){
70 | 			int a,b,c;
71 | 			scanf("%d %d %d",&a,&b,&c);
72 | 			op[i]=c;
73 | 			if(a==0)
74 | 				izq[i]=-1;
75 | 			else{
76 | 				izq[i]=a;
77 | 			}
78 | 			
79 | 			if(b==0)
80 | 				der[i]=-1;
81 | 			else {
82 | 				der[i]=b;
83 | 			}
84 | 		}	
85 | 		
86 | 		
87 | 		memset(memo,-1,sizeof(memo));
88 | 		cout<< (dp(1,0,1)+dp(1,1,0))%MOD<<endl;
89 | 	}
90 | 	
91 | 	return 0;
92 | }
93 | 


--------------------------------------------------------------------------------
/solucionario regional 2017/d.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<cstring>
 3 | #include<cstdio>
 4 | #include<vector>
 5 | #include<cmath>
 6 | #include<sstream>
 7 | #include<algorithm>
 8 | #include<set>
 9 | #include<queue>
10 | using namespace std;
11 | set<pair<pair<int,int>,int> >S;
12 | int f[100005];
13 | 
14 | int main(){
15 | 	//freopen("in.txt","r",stdin);
16 | 	//freopen("out.txt","w",stdout);
17 | 	
18 | 	int L,C,N;
19 | 	
20 | 	while(scanf("%d %d %d",&L,&C,&N)==3){
21 | 		int P,X,A,B;
22 | 		S.clear();
23 | 		
24 | 		memset(f,0,sizeof(f));
25 | 		
26 | 		S.insert(make_pair(make_pair(0,L-1),1) );
27 | 		f[1]=L;
28 | 		
29 | 		for(int caso=0;caso<N;caso++){
30 | 			scanf("%d %d %d %d",&P,&X,&A,&B);
31 | 			long long fp=f[P];
32 | 			long long LL=L;
33 | 			
34 | 			int M1= (A+fp*fp)%LL;
35 | 			int M2= (A+(fp+B)*(fp+B))%LL;
36 | 			
37 | 			if(M1>M2)swap(M1,M2);
38 | 			
39 | 			set<pair<pair<int,int>,int> >::iterator it=S.begin();
40 | 			it=S.lower_bound(make_pair(make_pair(M1+1,0),0));
41 | 			--it;
42 | 			set<pair<pair<int,int>,int> >::iterator aux=it;
43 | 			vector<pair<pair<int,int>,int> >del;
44 | 			vector<pair<pair<int,int>,int> >ins;
45 | 			
46 | 			while(true){
47 | 				if(it==S.end())break;
48 | 				pair<pair<int,int>,int> P=*it;
49 | 				if(P.first.first>M2)break;
50 | 				
51 | 				//S.erase(it);
52 | 				f[P.second]-=(P.first.second-P.first.first+1);
53 | 				
54 | 				if(P.first.first<M1){   //only once time
55 | 					//S.insert(make_pair(make_pair(P.first.first,M1-1),P.second ));
56 | 					ins.push_back(make_pair(make_pair(P.first.first,M1-1),P.second ));
57 | 					f[P.second]+=M1-1-P.first.first+1;
58 | 				}
59 | 				
60 | 				if(P.first.second>M2){ //only once time
61 | 					//S.insert(make_pair(make_pair(M2+1,P.first.second),P.second ));
62 | 					ins.push_back(make_pair(make_pair(M2+1,P.first.second),P.second ));
63 | 					f[P.second]+=P.first.second-(M2+1)+1;
64 | 				}
65 | 				
66 | 				//several
67 | 				del.push_back(P);
68 | 				f[X]+=min(M2,P.first.second)-max(M1,P.first.first)+1;
69 | 				++it;
70 | 			}
71 | 			
72 | 			// we update the values in the set in the end, because this could be affect the last iterator 
73 | 			for(int i=0;i<del.size();i++)
74 | 				S.erase(del[i]);
75 | 			for(int i=0;i<ins.size();i++)//at most twice
76 | 				S.insert(ins[i]);
77 | 			S.insert(make_pair(make_pair(M1,M2),X));
78 | 		}
79 | 		
80 | 		
81 | 		
82 | 		int maxi=0;
83 | 		for(int i=1;i<=C;i++)maxi=max(maxi,f[i]);
84 | 		cout<<maxi<<endl;
85 | 	}
86 | 	
87 | 	return 0;
88 | }
89 | 
90 | 
91 | 


--------------------------------------------------------------------------------
/solucionario regional 2017/f.cpp:
--------------------------------------------------------------------------------
  1 | #include<iostream>
  2 | #include<cstring>
  3 | #include<map>
  4 | #include<cstdio>
  5 | #include<vector>
  6 | #include<cmath>
  7 | #include<sstream>
  8 | #include<algorithm>
  9 | #include<set>
 10 | #include<queue>
 11 | using namespace std;
 12 | struct node{
 13 | 	long long b,f,d;
 14 | 	node(long long _b,long long _f,long long _d){
 15 | 		b=_b;
 16 | 		f=_f;
 17 | 		d=_d;
 18 | 	}
 19 | 	node(){}
 20 | };
 21 | 
 22 | bool operator<(node a,node b){
 23 | 	if(a.b!=b.b)return a.b<b.b;
 24 | 	if(a.f!=b.f)return a.f>b.f;
 25 | 	return a.d>b.d;
 26 | }
 27 | 
 28 | vector<node>v;
 29 | 
 30 | 
 31 | long long tree[100009];
 32 | long long MaxVal=100005;
 33 | long long read(int idx){
 34 |     if(idx==0)return 0;
 35 | 	long long sum = 0;
 36 | 	while (idx > 0){
 37 | 		sum = max(sum,tree[idx]);
 38 | 		idx -= (idx & -idx);
 39 | 	}
 40 | 	return sum;
 41 | }
 42 | 
 43 | void update(int idx ,long long val){
 44 | 	while (idx <= MaxVal){
 45 | 		tree[idx] = max(tree[idx],val);
 46 | 		idx += (idx & -idx);
 47 | 	}
 48 | }
 49 | 
 50 | int main(){
 51 | 	
 52 | 	int n;
 53 | 	
 54 | 	while(cin>>n){
 55 | 		v.clear();
 56 | 		
 57 | 		map<pair<int,int>,long long>ac;
 58 | 		
 59 | 		for(int i=0;i<n;i++){
 60 | 			int b,f,d;
 61 | 			scanf("%d %d %d",&b,&f,&d);
 62 | 			ac[make_pair(b,f)]+=d;
 63 | 		}
 64 | 		
 65 | 		for(map<pair<int,int>,long long>::iterator it=ac.begin(); it!=ac.end(); ++it){
 66 | 			pair<int,int>P=it->first;
 67 | 			long long Q=it->second;
 68 | 			v.push_back(node(P.first,P.second,Q));	
 69 | 		}
 70 | 		
 71 | 		sort(v.begin(),v.end());
 72 | 		n=v.size();		
 73 | 		//coordinate compression f
 74 | 		set<long long>S;
 75 | 		for(int i=0;i<v.size();i++)S.insert(v[i].f);
 76 | 		map<long long,long long>m;
 77 | 		int cont=1;
 78 | 		for(set<long long>::iterator it=S.begin(); it!=S.end(); ++it)m[*it]=cont++;
 79 | 		
 80 | 		for(int i=0;i<n;i++)v[i].f=m[v[i].f];
 81 | 		
 82 | 		memset(tree,0,sizeof(tree));
 83 | 		long long last=v[0].b;
 84 | 		long long maxi=0;
 85 | 		
 86 | 		
 87 | 		//O(nlogn)
 88 | 		for(int i=0;i<v.size();){
 89 | 			while(i<v.size()){
 90 | 				if(v[i].b!=last)break;
 91 | 				
 92 | 				long long value=read(v[i].f-1);
 93 | 				long long ac=read(v[i].f);
 94 | 				
 95 | 				update(v[i].f,max(value+v[i].d,ac ));
 96 | 				maxi=max(maxi,max(value+v[i].d, ac));	
 97 | 				i++;
 98 | 			}
 99 | 			
100 | 			if(i==v.size())break;
101 | 			last=v[i].b;
102 | 		}
103 | 		
104 | 		cout<<maxi<<endl;
105 | 	}
106 | 		
107 | 			
108 | 	return 0;
109 | }
110 | 
111 | 
112 | 


--------------------------------------------------------------------------------
/solucionario regional 2016/b.cpp:
--------------------------------------------------------------------------------
  1 | #include<iostream>
  2 | #include<cstring>
  3 | #include<cstdio>
  4 | #include<vector>
  5 | #include<cmath>
  6 | #include<sstream>
  7 | #include<algorithm>
  8 | #include<set>
  9 | #include<cassert>
 10 | #include<queue>
 11 | #include<map>
 12 | using namespace std;
 13 | set<int>adj[100001];
 14 | 
 15 | int main(){
 16 | 	//freopen("in.txt","r",stdin);
 17 | 	//freopen("out.txt","w",stdout);
 18 | 	
 19 | 	int n,m,a,b;
 20 | 	
 21 | 	while(cin>>n>>m>>a>>b){
 22 | 		for(int i=0;i<n;i++)
 23 | 			if(adj[i].size()>0)adj[i].clear();
 24 | 		
 25 | 		set<pair<int,int> >size; // first value= size  , second value= node
 26 | 		
 27 | 		for(int i=0;i<m;i++){
 28 | 			int p,q;
 29 | 			scanf("%d %d",&p,&q);
 30 | 			p--;q--;
 31 | 			adj[p].insert(q);
 32 | 			adj[q].insert(p);
 33 | 		}
 34 | 		
 35 | 		for(int i=0;i<n;i++)
 36 | 			if(adj[i].size()>0)
 37 | 			size.insert(make_pair(adj[i].size(),i));
 38 | 		
 39 | 		
 40 | 		while(size.size()>0){
 41 | 			pair<int,int>P=*size.begin();
 42 | 			pair<int,int>Q=*(--size.end());
 43 | 			
 44 | 			int totnode=((int)size.size());	
 45 | 			
 46 | 			if(P.first>=a && totnode-Q.first-1>=b)break;
 47 | 			
 48 | 			if(P.first<a){
 49 | 				int id=P.second;
 50 | 				//set<int>eliminar=adj[id];
 51 | 				set<int>::iterator it=adj[id].begin();
 52 | 				int sizeId=adj[id].size();
 53 | 				size.erase(make_pair(sizeId,id));
 54 | 				
 55 | 				while(it!=adj[id].end()){
 56 | 					int node= *it;
 57 | 					int sizenode=adj[node].size();
 58 | 					
 59 | 					size.erase(make_pair(sizenode,node));
 60 | 					if(sizenode>1){
 61 | 						size.insert(make_pair(sizenode-1,node));
 62 | 					}
 63 | 					
 64 | 					// id to node					
 65 | 					adj[node].erase(id);
 66 | 					it++;
 67 | 				}
 68 | 				
 69 | 				adj[id].clear();		
 70 | 				continue;
 71 | 			}
 72 | 			
 73 | 			
 74 | 			if( totnode-Q.first-1<b && P!=Q){
 75 | 				int id=Q.second;
 76 | 				set<int>::iterator it=adj[id].begin();
 77 | 				int sizeId=adj[id].size();
 78 | 				size.erase(make_pair(sizeId,id));
 79 | 				
 80 | 				while(it!=adj[id].end()){
 81 | 					int node= *it;
 82 | 					int sizenode=adj[node].size();
 83 | 					size.erase(make_pair(sizenode,node));
 84 | 					if(sizenode>1){
 85 | 						size.insert(make_pair(sizenode-1,node));
 86 | 					}
 87 | 					
 88 | 					// id to node					
 89 | 					adj[node].erase(id);
 90 | 					it++;
 91 | 				}
 92 | 				
 93 | 				adj[id].clear();				
 94 | 			}
 95 | 			
 96 | 		}
 97 | 		
 98 | 		cout<<size.size()<<endl;
 99 | 	}
100 | 
101 |     return 0;
102 | }
103 | 
104 | 


--------------------------------------------------------------------------------
/solucionario regional 2015/k.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | #define N 100000
 3 | #define M 100000
 4 | #define INF 1000000100
 5 | #define pb push_back
 6 | using namespace std;
 7 | 
 8 | int L[ M+5 ], S[ M+5 ], C[ M+5 ], R[ M+5 ], E[ N+5 ], dp[ N+5 ], AC[ N+5 ];
 9 | int tree[4*N+5];
10 | int n, m;
11 | vector<int>adj[ N +5 ];
12 | 
13 | void init(int node, int a, int b ){
14 |    if(a==b){
15 |       tree[node]= 0;
16 |       return;
17 |    }
18 |    init(2*node+1, a, (a+b)/2 );
19 |    init(2*node+2, (a+b)/2+1, b );
20 |    tree[node]=min( tree[2*node+1], tree[2*node+2] );
21 | }
22 | 
23 | int query(int node, int a, int b, int p, int q){
24 |    if(q<a || b<p)return INF;
25 |    if(a>=p && b<=q) return tree[node];
26 |    int v1=2*node+1;
27 |    int v2=2*node+2;
28 |    return min( query(v1, a, (a+b)/2, p, q), query(v2, (a+b)/2+1, b, p, q ) );
29 | }
30 | 
31 | void update(int node,int a,int b,int p,int val){
32 |    if(b<p || p<a)return;
33 |    if(a==b){
34 |       tree[node]=val;
35 |       return;
36 |    }
37 |    update(2*node+1, a, (a+b)/2, p, val);
38 |    update(2*node+2, (a+b)/2+1, b, p, val);
39 |    tree[node] =min( tree[2*node+1], tree[2*node+2] );
40 | }
41 | 
42 | bool check( int fin , int shop ){
43 | 	int ini = L[ shop ]-1;
44 | 	if( ini == 0 ) return S[ shop ] >= AC[ fin ];
45 | 	return S[ shop ] >= AC[ fin ] - AC[ ini-1 ];
46 | }
47 | 
48 | int search( int shop){
49 | 	int lo = L[ shop ]-1 , hi = n-1;
50 | 	if( !check( lo , shop ) )return -1;
51 | 	if( check( hi , shop ) ) return hi;
52 | 	while( hi-lo >1 ){
53 | 		int mi = (lo + hi )/2;
54 | 		if( check( mi, shop) ) lo =mi;
55 | 		else hi = mi;
56 | 	}
57 | 	return lo;
58 | }
59 | 
60 | void doit(){
61 | 	for( int i=0 ; i<n ; ++i ){
62 | 		scanf("%d", &E[ i ] );
63 | 		adj[ i ].clear();
64 | 	}
65 | 	AC[ 0 ] = E[ 0 ];
66 | 	for( int i=1 ; i<n ; ++i ) AC[ i ] = AC[ i-1 ] + E[ i ];
67 | 	for( int i=0 ; i<m ; ++i ){
68 | 		scanf("%d%d%d", &L[ i ], &S[ i ], &C[ i ] );
69 | 		R[ i ] = search( i );
70 | 		if( R[ i ] != -1 ) adj[ L[ i ] -1 ].pb( i );
71 | 	}
72 | 
73 | 	init( 0 , 0 , n );
74 | 	dp[ n ] = 0;
75 | 	update( 0, 0, n, n, 0 );
76 | 	for( int i =n-1; i>=0; i-- ){
77 | 		dp[ i ] = INF;
78 | 		for( int j =0 ; j<adj[ i ].size() ; ++ j ){
79 | 			int shop = adj[ i ][ j ];
80 | 			dp[ i ] = min( dp[ i ] , C[ shop ] + query( 0, 0,  n, i+1, R[ shop ] +1 ) );
81 | 		}
82 | 		update( 0, 0, n, i, dp[ i ] );
83 | 	}
84 | 	if( dp[ 0 ] >= INF )puts("-1");
85 | 	else printf("%d\n" , dp[ 0 ] );
86 | }
87 | 
88 | int main(){
89 | 	while( scanf("%d%d" ,&n,&m) ==2 ) doit();
90 | }
91 | 
92 | 
93 | 
94 | 
95 | 
96 | 
97 | 
98 | 
99 | 


--------------------------------------------------------------------------------
/solucionario regional 2013/e.cpp:
--------------------------------------------------------------------------------
 1 | #include <vector>
 2 | #include <list>
 3 | #include <map>
 4 | #include <set>
 5 | #include <queue>
 6 | #include <deque>
 7 | #include <stack>
 8 | #include <bitset>
 9 | #include <algorithm>
10 | #include <functional>
11 | #include <numeric>
12 | #include <utility>
13 | #include <sstream>
14 | #include <iostream>
15 | #include <iomanip>
16 | #include <cstdio>
17 | #include <cmath>
18 | #include <cstdlib>
19 | #include <ctime>
20 | #include <string.h>
21 | #include <stdio.h>
22 | #define all(v) (v).begin(),(v).end()
23 | #define rall(v) (v).rbegin(),(v).rend()
24 | using namespace std;  // H A M L E T
25 | int cant[10];
26 | long long memo[11][11][101];
27 | long long C[101][101];
28 | 
29 | void combinatoria(){
30 |     C[0][0]=1;
31 |     for(int i=1;i<=100;i++){
32 |         C[i][0]=1;C[i][i]=1;
33 |         for(int j=1;j<i;j++){
34 |             C[i][j]=(C[i-1][j-1]+C[i-1][j])%1000000007;
35 |         }
36 |     }
37 | }
38 | 
39 | 
40 | long long dp(int pos,int modulo,int posi,int nega){
41 |     if(pos==10)return (modulo==0);
42 |     if(memo[pos][modulo][posi]!=-1)return memo[pos][modulo][posi];
43 |     
44 |     long long dev=0;
45 |     int tam=posi+nega;
46 |     int tot=cant[pos];
47 |     
48 |     for(int i=0;i<=min(posi,tot);i++){
49 |         int primer=i;
50 |         int segundo=tot-i;
51 |         if(segundo<=nega){
52 |             long long aux=(C[posi][primer]*C[nega][segundo])%1000000007;
53 |             dev+=aux*dp(pos+1,(modulo+primer*pos-segundo*pos+110000)%11,posi-primer,nega-segundo);
54 |             dev=dev%1000000007;
55 |         }
56 |     }
57 |     
58 |     
59 |     memo[pos][modulo][posi]=dev;
60 |     return dev;
61 | }
62 | 
63 | int main(){
64 |     combinatoria();
65 |     
66 |     string s;
67 |     while(cin>>s){
68 |         memset(cant,0,sizeof(cant));
69 |         for(int i=0;i<s.size();i++)
70 |             cant[s[i]-'0']++;    
71 |         
72 |         int posi=(s.size()+1)/2;
73 |         int nega=s.size()-posi;
74 |         
75 |         long long dev=0;
76 |         for(int i=1;i<=9;i++){
77 |             if(cant[i]==0)continue;
78 |             int aux=i;
79 |             if(s.size()%2==0)nega--,aux=11-i;
80 |                 else posi--;
81 |             
82 |             cant[i]--;
83 |             memset(memo,-1,sizeof(memo));
84 |             
85 |             
86 |             dev=(dev+dp(0,aux,posi,nega))%1000000007;
87 |             cant[i]++;
88 |             if(s.size()%2==0)nega++;
89 |                 else posi++;
90 |             
91 |         }
92 |         
93 |         cout<<dev<<endl;
94 |     }
95 |     return 0;
96 | }
97 | 


--------------------------------------------------------------------------------
/solucionario regional 2015/g.cpp:
--------------------------------------------------------------------------------
  1 | #include<iostream>
  2 | #include<cstring>
  3 | #include<cstdio>
  4 | #include<algorithm>
  5 | #include<sstream>
  6 | #include<set>
  7 | #include<cstring>
  8 | #include<vector>
  9 | #include<map>
 10 | #include<cassert>
 11 | #include<cmath>
 12 | #include<queue>
 13 | using namespace std;
 14 | 
 15 | 
 16 | struct nodo{
 17 |     int q;
 18 |     double d;
 19 | 
 20 |     nodo(){}
 21 |     nodo(int _q,double _d){
 22 |         q=_q;
 23 |         d=_d;
 24 |     }
 25 | };
 26 | 
 27 | 
 28 | bool operator<(nodo a, nodo b){
 29 |     if(a.d!=b.d)return a.d>b.d;
 30 |     return a.q<b.q;
 31 | }
 32 | 
 33 | int n,m;
 34 | vector<pair<int,pair<int,int> > >v[1002];
 35 | 
 36 | 
 37 | 
 38 | double t;
 39 | double d[1002];
 40 | 
 41 | double dijkstra(){
 42 |     for(int i=1;i<=n;i++)d[i]=1e+12;
 43 |     d[1]=0;
 44 |     double dev=0;
 45 |     priority_queue<nodo >Q;
 46 |     Q.push(nodo(1,0));
 47 |     
 48 |     while(!Q.empty()){
 49 |         nodo x=Q.top();
 50 |         Q.pop();
 51 |         int q=x.q;
 52 |         double dis=x.d;
 53 |         
 54 |         for(int i=0;i<v[q].size();i++){
 55 |             if( d[v[q][i].first] >  d[q]+ (v[q][i].second.first*t+v[q][i].second.second)+1e-9 ){
 56 |                 d[v[q][i].first] =d[q]+ (v[q][i].second.first*t+v[q][i].second.second);
 57 |                 Q.push(nodo(v[q][i].first,d[v[q][i].first]  ));
 58 |             }
 59 |         }
 60 |     }
 61 |     
 62 |     return d[n];
 63 | }
 64 | 
 65 | 
 66 | double f(double x){
 67 |     t=x;
 68 |     return dijkstra();
 69 |     //for(int i=0;i<1002;i++)memo[i]=-1;
 70 |     //return dp(1);
 71 | }
 72 | 
 73 | int main(){
 74 | 
 75 | 
 76 |     while(cin>>n>>m){
 77 |         for(int i=0;i<1002;i++)v[i].clear();
 78 | 
 79 |         int I,J,A,B;
 80 |         double lo=0;
 81 |         double hi=1440;
 82 |         
 83 |         for(int i=0;i<m;i++){
 84 |             cin>>I>>J>>A>>B;
 85 |             v[I].push_back(make_pair(J,make_pair(A,B)));
 86 |             v[J].push_back(make_pair(I,make_pair(A,B)));
 87 |             
 88 |             if(A==0)continue;
 89 |             if(A>0){if(B<0)lo=max(lo,-(double)B/A);}
 90 |             if(A<0){if(B>0)hi=min(hi,-(double)B/A);}
 91 |         }
 92 |         
 93 |         
 94 |         
 95 |         
 96 |         for(int it=0;it<100;it++){
 97 |             double me1=(2*lo+hi)/3;
 98 |             double me2=(lo+2*hi)/3;
 99 |             if(f(me1)<f(me2)){
100 |                 lo=me1;
101 |             }else{
102 |                 hi=me2;
103 |             }
104 |         }
105 | 
106 |         
107 |         printf("%.5lf\n",f(lo));
108 |     }
109 |     return 0;
110 | }
111 | 
112 | 


--------------------------------------------------------------------------------
/solucionario regional 2012/i.cpp:
--------------------------------------------------------------------------------
  1 | #include <ctime>
  2 | #include <numeric>
  3 | #include <functional>
  4 | #include <iostream>
  5 | #include <vector>
  6 | #include <algorithm>
  7 | #include <bitset>
  8 | #include <string>
  9 | #include <cstring>
 10 | #include <climits>
 11 | #include <cmath>
 12 | #include <cctype>
 13 | #include <sstream>
 14 | #include <map>
 15 | #include <set>
 16 | #include <cstdio>
 17 | #include <queue>
 18 | using namespace std;
 19 | int c[100000];
 20 | int tree[400001];
 21 | 
 22 | void init(int node,int a,int b){
 23 |     if(a==b){
 24 |         tree[node]=c[a];
 25 |         return ;    
 26 |     }
 27 |     
 28 |     init(2*node+1,a,(a+b)/2);
 29 |     init(2*node+2,(a+b)/2+1,b);
 30 |     
 31 |     tree[node]=tree[2*node+1]*tree[2*node+2];    
 32 | }
 33 | 
 34 | int query(int node,int a,int b,int p,int q){
 35 |     if( q<a || b<p )return 1;
 36 |     
 37 |     if(p<=a && b<=q){
 38 |         return tree[node];    
 39 |     }
 40 |     
 41 |     return query(2*node+1,a,(a+b)/2,p,q)*query(2*node+2,(a+b)/2+1,b,p,q);
 42 | }
 43 | 
 44 | void update(int node,int a,int b,int p,int val){
 45 |     if(p<a || b<p)return;
 46 |     
 47 |     if(a==b){
 48 |         tree[node]=val;    
 49 |         return ;
 50 |     }
 51 |     
 52 |     update(2*node+1,a,(a+b)/2,p,val);
 53 |     update(2*node+2,(a+b)/2+1,b,p,val);
 54 |     
 55 |     tree[node]=tree[2*node+1]*tree[2*node+2]; 
 56 | }
 57 | 
 58 | int f(int t){
 59 |     if(t>0)return 1;
 60 |     if(t<0)return -1;
 61 |     return 0;    
 62 | }
 63 | 
 64 | int main(){
 65 |     //freopen("in.txt","r",stdin);
 66 |     //freopen("out.txt","w",stdout);
 67 |     
 68 |     int n,m;
 69 |     
 70 |     while(scanf("%d %d",&n,&m)==2){
 71 |         int aux;
 72 |         
 73 |         for(int i=0;i<n;i++){
 74 |             scanf("%d",&aux);
 75 |             c[i]=f(aux);
 76 |         }
 77 |         
 78 |         init(0,0,n-1);
 79 |         
 80 |         
 81 |         for(int i=0;i<m;i++){
 82 |             char ch;
 83 |             cin>>ch;
 84 |             
 85 |             if(ch=='C'){
 86 |                 int a,val;
 87 |                 scanf("%d %d",&a,&val);
 88 |                 a--;
 89 |                 update(0,0,n-1,a,f(val));
 90 |             }else{
 91 |                 int a,b;
 92 |                 scanf("%d %d",&a,&b);
 93 |                 a--;b--;
 94 |                 int x=query(0,0,n-1,a,b);
 95 |                 
 96 |                 if(x==0)printf("0");
 97 |                 if(x>0)printf("+");
 98 |                 if(x<0)printf("-");
 99 |                 
100 |             }
101 |         }
102 |         printf("\n");
103 |     }
104 |      
105 |     return 0;
106 | }
107 | 


--------------------------------------------------------------------------------
/solucionario regional 2012/f.cpp:
--------------------------------------------------------------------------------
 1 | #include <ctime>
 2 | #include <numeric>
 3 | #include <functional>
 4 | #include <iostream>
 5 | #include <vector>
 6 | #include <algorithm>
 7 | #include <bitset>
 8 | #include <string>
 9 | #include <cstring>
10 | #include <climits>
11 | #include <cmath>
12 | #include <cctype>
13 | #include <sstream>
14 | #include <map>
15 | #include <set>
16 | #include <cstdio>
17 | #include <queue>
18 | using namespace std;
19 | char c[603][303];
20 | bool puede[603][603][4];
21 | bool visited[603][603];
22 | 
23 | int main(){
24 |     //freopen("in.txt","r",stdin);
25 |     //freopen("out.txt","w",stdout);
26 |     
27 |     int n;
28 |     // arriba abajo derecha izquierda
29 |     int di[4]={-1,1,0,0};
30 |     int dj[4]={0,0,1,-1};
31 |     
32 |     while(cin>>n){
33 |         
34 |         memset(puede,1,sizeof(puede));
35 |         memset(visited,0,sizeof(visited));
36 |         
37 |         for(int i=0;i<2*n-1;i++){
38 |             for(int j=0;j<n;j++){
39 |                 int x=i;
40 |                 int y=2*j+(i&1);
41 |                 char ch;
42 |                 cin>>ch;
43 |                 
44 |                 if(ch=='H'){
45 |                     puede[x][y][1]=puede[x][y+1][1]=0;
46 |                     puede[x+1][y][0]=puede[x+1][y+1][0]=0;
47 |                 }else{
48 |                     puede[x][y][2]=puede[x][y+1][3]=0;
49 |                     puede[x+1][y][2]=puede[x+1][y+1][3]=0;
50 |                 }
51 |                 
52 |             }   
53 |         }
54 |         
55 |         int cont=-1;
56 |         
57 |         for(int i=0;i<2*n;i++){
58 |             for(int j=0;j<2*n+1;j++){
59 |                 if(!visited[i][j]){
60 |                     queue<pair<int,int> >Q; 
61 |                     Q.push(make_pair(i,j));
62 |                     visited[i][j]=1;
63 |                     
64 |                     while(!Q.empty()){
65 |                         pair<int,int>P=Q.front();    
66 |                         Q.pop();
67 |                         for(int i=0;i<4;i++){
68 |                             int X=P.first+di[i];
69 |                             int Y=P.second+dj[i];
70 |                             if(X>=0 && X<2*n && Y>=0 && Y<2*n+1)
71 |                                 if(!visited[X][Y]&& puede[P.first][P.second][i]){
72 |                                     visited[X][Y]=1;
73 |                                     Q.push(make_pair(X,Y));    
74 |                                 }
75 |                         }
76 |                         
77 |                     }
78 |                     cont++;        
79 |                 }
80 |             }
81 |         }
82 |         
83 |         cout<<cont<<endl;
84 |     }
85 |      
86 |     return 0;
87 | }
88 | 


--------------------------------------------------------------------------------
/solucionario regional 2015/b.cpp:
--------------------------------------------------------------------------------
  1 | #include<iostream>
  2 | #include<cstring>
  3 | #include<cstdio>
  4 | #include<algorithm>
  5 | #include<sstream>
  6 | #include<set>
  7 | #include<cstring>
  8 | #include<vector>
  9 | #include<map>
 10 | #include<cassert>
 11 | #include<cmath>
 12 | #include<queue>
 13 | #define N 201
 14 | using namespace std;
 15 | int n;
 16 | int match[ N + 5 ];
 17 | bool vis[ N + 5 ];
 18 | vector<int> G[ N + 5 ];
 19 | vector<int>v[N+5];
 20 | 
 21 | int dfs( int u ){
 22 | 	if( vis[ u ] ) return 0;
 23 | 	vis[ u ] = 1;
 24 | 	for(int i=0;i<G[u].size();i++  /*auto v : G[ u ]*/ ){
 25 |         int v=G[u][i];
 26 |         if( match[v] == -1 || dfs(match[v] ) ){
 27 | 			match[v] = u;
 28 | 			return 1;
 29 | 		}
 30 | 	}
 31 | 	return 0;
 32 | }
 33 | 
 34 | 
 35 | int main(){
 36 | 
 37 | //freopen("in.txt","r",stdin);
 38 | //freopen("out.txt","w",stdout);
 39 | 
 40 |     int q;
 41 |     while(cin>>n>>q){
 42 |         for(int i=0;i<205;i++)v[i].clear();
 43 |         bool todo=0;
 44 |         for(int i=0;i<n;i++){
 45 |             int t,aux;
 46 |             cin>>t;
 47 |             if(t==n)todo=1;
 48 |             for(int j=0;j<t;j++){
 49 |                 cin>>aux;
 50 |                 aux--;
 51 |                 v[i].push_back(aux);
 52 |             }
 53 |         }
 54 |         
 55 |         while(q--){
 56 |             for(int i=0;i<205;i++)G[i].clear();
 57 |             memset(match,-1,sizeof(match));
 58 | 
 59 |             int t;
 60 |             cin>>t;
 61 |             if(t==0){
 62 |                 if(todo)
 63 |                     cout<<"N"<<endl;
 64 |                 else
 65 |                     cout<<"Y"<<endl;
 66 |                 continue;
 67 |             }
 68 |             
 69 |             int aux;
 70 |             bool visited[n];
 71 |             memset(visited,0,sizeof(visited));
 72 |             for(int i=0;i<t;i++){
 73 |                 cin>>aux;
 74 |                 aux--;
 75 |                 visited[aux]=1;
 76 |             }
 77 |             
 78 |            
 79 |             for(int i=0;i<n;i++){
 80 |                 for(int j=0;j<v[i].size();j++){
 81 |                     if(visited[ v[i][j] ]){
 82 |                         G[i].push_back(n+v[i][j]);
 83 |                         //cap[i+1][n+1+v[i][j]]=1;
 84 |                     }
 85 |                 }
 86 |             }
 87 | 
 88 |             int dev=0;
 89 |             for(int i=0;i<2*n;i++){
 90 |                 memset(vis,0,sizeof(vis));
 91 |                 dev+=dfs(i);
 92 |             }
 93 |             
 94 |             //for(int i=0;i<n;i++)cap[0][i+1]=1;
 95 |             //for(int i=0;i<n;i++)cap[n+1+i][size]=1;
 96 |             ///cout<<maxflow( 0, size )<<endl;
 97 |             if( dev== t )
 98 |                 cout<<"Y"<<endl;
 99 |             else
100 |                 cout<<"N"<<endl;
101 |             
102 |         }
103 |         
104 |     }
105 | 
106 | 
107 |     return 0;
108 | }
109 | 
110 | 
111 | 


--------------------------------------------------------------------------------
/solucionario regional 2013/g.cpp:
--------------------------------------------------------------------------------
  1 | #include <vector>
  2 | #include <list>
  3 | #include <map>
  4 | #include <set>
  5 | #include <queue>
  6 | #include <deque>
  7 | #include <stack>
  8 | #include <bitset>
  9 | #include <algorithm>
 10 | #include <functional>
 11 | #include <numeric>
 12 | #include <utility>
 13 | #include <sstream>
 14 | #include <iostream>
 15 | #include <iomanip>
 16 | #include <cstdio>
 17 | #include <cmath>
 18 | #include <cstdlib>
 19 | #include <ctime>
 20 | #include <string.h>
 21 | #include <stdio.h>
 22 | #define all(v) (v).begin(),(v).end()
 23 | #define rall(v) (v).rbegin(),(v).rend()
 24 | using namespace std;  // H A M L E T
 25 | int c[100001];
 26 | int n;
 27 | int tree2[100001][20];
 28 | int loga[300001];
 29 | 
 30 | void rmq2(){
 31 |     for(int i=0;i<n;i++)tree2[i][0]=c[i];
 32 |     for(int i=1;i<=16;i++)
 33 |         for(int j=0;j+(1<<i)-1<=n;j++)
 34 |             tree2[j][i]=min(tree2[j][i-1], tree2[j+(1<<(i-1))][i-1]);    
 35 | }
 36 | 
 37 | int query2(int a,int b){
 38 |     int k=b-a+1;
 39 |     return min(tree2[a][loga[k]], tree2[b+1-(1<<loga[k])][loga[k]] );
 40 | }
 41 | 
 42 | 
 43 | int main(){
 44 |     
 45 |     
 46 |     loga[1]=0;
 47 |     for(int i=1;i<=16;i++)
 48 |         for(int j=(1<<i);j<(1<<(i+1));j++)
 49 |             loga[j]=i;
 50 |     
 51 |     
 52 |     while(cin>>n){
 53 |         for(int i=0;i<n;i++)
 54 |             scanf("%d",&c[i]);
 55 |         
 56 |         rmq2();
 57 |         
 58 |         
 59 |         int der[n];
 60 |         der[n-1]=n;
 61 |         for(int i=n-2;i>=0;i--){
 62 |             der[i]=i+1;
 63 |             while(der[i]<n && c[i]>=c[der[i]])
 64 |                 der[i]=der[der[i]];    
 65 |         }
 66 |         
 67 |         int izq[n];
 68 |         izq[0]=-1;
 69 |         
 70 |         for(int i=1;i<n;i++){
 71 |             izq[i]=i-1;    
 72 |             while(izq[i]>=0 && c[i]>=c[izq[i]])
 73 |                 izq[i]=izq[izq[i]];
 74 |         }
 75 |         
 76 |         
 77 |         vector<int>dev;
 78 |         
 79 |         for(int i=1;i+1<n;i++){
 80 |             if(c[i]>c[i+1] && c[i]>c[i-1]){
 81 |                 int ini=izq[i];
 82 |                 
 83 |                 int nivel=c[i];
 84 |                 
 85 |                 if(ini!=-1)
 86 |                     nivel=c[i]-query2(ini,i);
 87 |                 
 88 |                 if(nivel<150000)continue;
 89 |                 
 90 |                 ini=der[i];
 91 |                 nivel=c[i];
 92 |                 
 93 |                 if(ini!=n)
 94 |                     nivel=c[i]-query2(i,ini);
 95 |                 
 96 |                 if(nivel<150000)continue;
 97 |                 
 98 |                 dev.push_back(i+1);
 99 |             }    
100 |         }
101 |         
102 |         
103 |         printf("%d",dev[0]);
104 |         
105 |         for(int i=1;i<dev.size();i++)
106 |             printf(" %d",dev[i]);
107 |         printf("\n");
108 |     }
109 |     
110 |     return 0;
111 | }
112 | 


--------------------------------------------------------------------------------
/solucionario regional 2012/a.cpp:
--------------------------------------------------------------------------------
  1 | #include <ctime>
  2 | #include <numeric>
  3 | #include <functional>
  4 | #include <iostream>
  5 | #include <vector>
  6 | #include <algorithm>
  7 | #include <bitset>
  8 | #include <string>
  9 | #include <cstring>
 10 | #include <climits>
 11 | #include <cmath>
 12 | #include <cctype>
 13 | #include <sstream>
 14 | #include <map>
 15 | #include <set>
 16 | #include <cstdio>
 17 | #include <queue>
 18 | using namespace std;
 19 | 
 20 | struct point{
 21 |     point(){}
 22 |     long long x,y;
 23 |     point(long long _x,long long _y){
 24 |         x=_x;y=_y;    
 25 |     }
 26 | };
 27 | 
 28 | long long operator %(point a, point b){return a.x*b.y-b.x*a.y;}
 29 | point operator -(point a,point b){return point(a.x-b.x,a.y-b.y);}
 30 | 
 31 | int n,K;
 32 | int tam;
 33 | long long p[1001],w[1001];
 34 | long long dp[1001][1001];
 35 | long long W[1001];
 36 | long long G[1001];
 37 | point T[1001];
 38 | 
 39 | inline void add(long long x, long long y){
 40 |     point p(x, y);
 41 |     while(tam>= 2 && (p-T[tam-1])%(p-T[tam-2])>= 0)tam--;
 42 |     T[tam++] = p;
 43 |     //if(tam>=2 && T[tam - 1].x == T[tam - 2].x) tam--;
 44 | }
 45 | 
 46 | inline long long evalua(int a,int pos){
 47 |     return T[a].x*W[pos] +T[a].y ;
 48 | }
 49 | 
 50 | int main(){
 51 |     
 52 |     //freopen("in.txt","r",stdin);
 53 |     //freopen("out.txt","w",stdout);
 54 |     
 55 |     while(cin>>n>>K){
 56 |         W[0]=G[0]=0;
 57 |         
 58 |         for(int i=0;i<n;i++){
 59 |             scanf("%lld %lld",&p[i],&w[i]);
 60 |             G[i+1]=G[i]+w[i]*p[i];
 61 |             W[i+1]= W[i]+w[i];
 62 |         }
 63 |                     
 64 |         for(int k=0;k<=K;k++){
 65 |             tam=0;
 66 |             for(int pos=n;pos>=0;pos--){
 67 |                 dp[pos][k]=1LL<<60;
 68 |                 if(pos==n){
 69 |                     if(k==0)dp[pos][k]=0;
 70 |                     continue;
 71 |                 }
 72 |                 
 73 |                 if(k==0)continue;
 74 |                 
 75 |                 if(dp[pos+1][k-1]!=(1LL<<60))
 76 |                     add(-p[pos],dp[pos+1][k-1]+p[pos]*W[pos+1]-G[pos+1] );
 77 |                 
 78 |                 int low=0;int hi=tam-1;
 79 |                 
 80 |                 
 81 |                 long long mid1,mid2;
 82 |                 
 83 |                 while(hi-low>=4){
 84 |                     mid1=(2*low+hi)/3;
 85 |                     mid2=(low+2*hi)/3;
 86 |                     if(evalua(mid1,pos)< evalua(mid2,pos) ){
 87 |                         hi=mid2;    
 88 |                     }else{
 89 |                         low=mid1;       
 90 |                     }    
 91 |                 }
 92 |                 
 93 |                 long long mini=1LL<<60;
 94 |                 for(int jj=low;jj<=hi;jj++){
 95 |                     mini=min(mini,evalua(jj,pos)+G[pos]);
 96 |                 }
 97 |                 
 98 |                 dp[pos][k]=mini;
 99 |             }
100 |         }
101 |         
102 |         cout<<dp[0][K]<<endl; 
103 |     }
104 |     
105 |     return 0;
106 | }
107 | 
108 | 
109 | 


--------------------------------------------------------------------------------
/solucionario regional 2015/k2.cpp:
--------------------------------------------------------------------------------
  1 | #include<iostream>
  2 | #include<cstring>
  3 | #include<cstdio>
  4 | #include<algorithm>
  5 | #include<cstring>
  6 | #include<vector>
  7 | #include<cmath>
  8 | #include<queue>
  9 | #define MAX 100005
 10 | using namespace std;  
 11 | 
 12 | int v[MAX];
 13 | int tree[4*MAX];
 14 | int id[MAX];
 15 | int dp[MAX];
 16 | 
 17 | struct node{
 18 |     int L,S,C;
 19 |     node(int _L,int _S,int _C){
 20 |         L=_L;
 21 |         S=_S;
 22 |         C=_C;
 23 |     }
 24 | };
 25 | 
 26 | int query(int a,int b,int node,int p,int q){
 27 | 
 28 |     if(p<=a && b<=q)return tree[node];
 29 |     if(p>b || q<a)return 1<<30;
 30 | 
 31 |     int x=query(a,(a+b)/2,2*node+1,p,q);
 32 |     int y=query((a+b)/2+1,b,2*node+2,p,q);
 33 |     
 34 |     return min(x,y);
 35 | }
 36 | 
 37 | 
 38 | void update(int a, int b, int node , int ind , int val ){
 39 |     if(ind>b || ind<a)return;
 40 | 
 41 |     if(a==b){
 42 | 	   tree[node]= val;
 43 | 	   return ;
 44 |     }
 45 | 
 46 |     int v1 = 2*node+1;
 47 |     int v2 = 2*node+2;
 48 |     update(a,(a+b)/2 ,v1,ind, val );
 49 |     update((a+b)/2+1, b, v2, ind , val );
 50 | 
 51 |     tree[node]= min(tree[v1] , tree[v2]);
 52 | }
 53 | 
 54 | 
 55 | vector<pair<int,int> > niv[MAX];
 56 | int F[MAX];
 57 | 
 58 | int main(){
 59 |     
 60 |     int oo=(1<<30)-5;
 61 |     int n,m;
 62 | 
 63 |     while(cin>>n>>m){
 64 |         F[0]=0;
 65 |         
 66 |         for(int i=0;i<n;i++){
 67 |             scanf("%d",&v[i]);
 68 |             F[i+1]=F[i]+v[i];
 69 |         }
 70 | 
 71 |         int a,b,c;
 72 |         for(int i=0;i<m;i++){
 73 |             scanf("%d %d %d",&a,&b,&c);
 74 |             a--;
 75 |             niv[a].push_back( make_pair(b,c) );
 76 |         }
 77 |         
 78 |         dp[n]=0;
 79 |         int pos=n-1;
 80 |         int tam=n+1;
 81 |         update(0,tam-1,0,n,0);
 82 |         
 83 |         
 84 |         for(int i=n-1;i>=0;i--){
 85 |             dp[i]=oo;
 86 |             update(0,tam-1,0,i,oo);
 87 |             if(niv[i].size()>0){
 88 |                 for(int j=0;j<niv[i].size();j++){
 89 |                     int S=niv[i][j].first;
 90 |                     int C=niv[i][j].second;
 91 |                     int lo=i;
 92 |                     int hi=n;
 93 |                     
 94 |                     if(S<v[i])continue;
 95 | 
 96 |                     while(lo+1!=hi){
 97 |                         int me=(lo+hi)/2;
 98 |                         if(F[me+1]-F[i] <=S){
 99 |                             lo=me;
100 |                         }else{
101 |                             hi=me;
102 |                         }
103 |                     }
104 |                     
105 |                     dp[i]=min(dp[i],C+query(0,tam-1,0,i+1,lo+1)  );
106 |                     update(0,tam-1,0,i,dp[i]);=
107 |                 }
108 |             }
109 |         }
110 |         
111 |         if(dp[0]>=oo){
112 |             cout<<-1<<endl;
113 |         }else{
114 |             cout<<dp[0]<<endl;
115 |         }
116 |         
117 |         for(int i=0;i<MAX;i++)if(niv[i].size()>0)niv[i].clear();
118 |     }
119 |     return 0;
120 | }
121 | 


--------------------------------------------------------------------------------
/solucionario regional 2016/k.cpp:
--------------------------------------------------------------------------------
  1 | #include<iostream>
  2 | #include<cstring>
  3 | #include<cstdio>
  4 | #include<vector>
  5 | #include<cmath>
  6 | #include<sstream>
  7 | #include<algorithm>
  8 | #include<set>
  9 | #include<cassert>
 10 | #include<queue>
 11 | #include<map>
 12 | using namespace std;
 13 | 
 14 | int source, sink;
 15 | int N=105;
 16 | int residual[105][105];
 17 | 
 18 | int find_path(){
 19 | 	bool visited[N];
 20 | 	memset(visited, 0, sizeof(visited));
 21 | 	
 22 | 	int from[N];
 23 | 	memset(from, -1, sizeof(from));
 24 | 	
 25 | 	queue <int> Q;
 26 | 	Q.push(source);
 27 | 	visited[source] = 1;
 28 | 	
 29 | 	int where;
 30 | 	
 31 | 	while(!Q.empty()){
 32 | 		where = Q.front();
 33 | 		Q.pop();
 34 | 		
 35 | 		if(where==sink) break;
 36 | 		
 37 | 		for(int i=0; i<N; i++){
 38 | 			if(residual[where][i] > 0 && !visited[i]){
 39 | 				Q.push(i);
 40 | 				visited[i] = 1;
 41 | 				from[i] = where;
 42 | 			}
 43 | 		}
 44 | 	}
 45 | 	
 46 | 	int path_cap = 1<<30;
 47 | 	where = sink;
 48 | 	while(from[where] > -1){
 49 | 		int prev = from[where];
 50 | 		path_cap = min(path_cap, residual[prev][where]);
 51 | 		where = prev;
 52 | 	}
 53 | 	
 54 | 	where = sink;
 55 | 	while(from[where] > -1){
 56 | 		int prev = from[where];
 57 | 		residual[prev][where] -= path_cap;
 58 | 		residual[where][prev] += path_cap;
 59 | 		where = prev;
 60 | 	}
 61 | 	
 62 | 	if(path_cap == 1<<30) return 0;
 63 | 	else return path_cap;
 64 | }
 65 | 
 66 | int max_flow(){
 67 | 	int flow = 0;
 68 | 	while(1){
 69 | 		int path_cap = find_path();
 70 | 		if(!path_cap) break;
 71 | 		else flow += path_cap;
 72 | 	}
 73 | 	return flow;
 74 | }
 75 | 
 76 | 
 77 | int main(){
 78 | 	//freopen("in.txt","r",stdin);
 79 | 	//freopen("out.txt","w",stdout);
 80 | 	
 81 | 	int n;
 82 | 	
 83 | 	while(scanf("%d",&n)==1){
 84 | 		int a[n],b[n];
 85 | 		
 86 | 		for(int i=0;i<n;i++){
 87 | 			scanf("%d",&a[i]);
 88 | 			scanf("%d",&b[i]);
 89 | 			a[i]--;b[i]--;
 90 | 		}
 91 | 		
 92 | 		int ans=0;
 93 | 		for(int i=0;i<n;i++){
 94 | 			memset(residual,0,sizeof(residual));
 95 |         	source=0;
 96 |         	sink=101;
 97 | 			
 98 | 			bool visited[n];
 99 | 			memset(visited,0,sizeof(visited));
100 | 			visited[i]=1;
101 | 			
102 | 			int kill=0; // villagers  always choose the werewolf
103 | 			for(int j=0;j<n;j++){
104 | 				if(a[j]==i || b[j]==i){
105 | 					visited[j]=1;
106 | 					kill++;
107 | 				}
108 | 			}
109 | 			
110 | 			if(kill<=1){
111 | 				ans++;
112 | 				continue;
113 | 			}
114 | 			
115 | 			for(int j=0;j<n;j++){
116 | 				residual[source][j+1]=kill-1;
117 | 				if(a[i]==j || b[i]==j)
118 | 					residual[source][j+1]=kill-2;
119 | 			}
120 | 			
121 | 			int notvisited=0;
122 | 			
123 | 			for(int j=0;j<n;j++){
124 | 				if(!visited[j]){
125 | 					residual[a[j]+1][n+j+1]=1;
126 | 					residual[b[j]+1][n+j+1]=1;
127 | 					residual[n+j+1][sink]=1;
128 | 					notvisited++;
129 | 				}
130 | 			}
131 | 			
132 | 			//cout<<"maxflow "<<i<<" "<<notvisited<<" "<<max_flow()<<endl;
133 | 			if(max_flow()!=notvisited){
134 | 				ans++;
135 | 			}
136 | 		}
137 | 		
138 | 		cout<<ans<<endl;
139 | 	}
140 | 	
141 | 	
142 |     return 0;
143 | }
144 | 
145 | 


--------------------------------------------------------------------------------
/solucionario regional 2015/f.cpp:
--------------------------------------------------------------------------------
  1 | #include<iostream>
  2 | #include<cstring>
  3 | #include<cstdio>
  4 | #include<algorithm>
  5 | #include<sstream>
  6 | #include<set>
  7 | #include<cstring>
  8 | #include<vector>
  9 | #include<map>
 10 | #include<cassert>
 11 | #include<cmath>
 12 | #include<queue>
 13 | using namespace std;
 14 | int tree[300001];
 15 | int maxVal=300000;
 16 | 
 17 | int query(int idx){
 18 |     int sum=0;
 19 |     while(idx!=0){
 20 |         sum+=tree[idx];
 21 |         idx-=(idx&-idx);
 22 |     }
 23 |     return sum;
 24 | }
 25 | 
 26 | void update(int idx,int val){
 27 |     while(idx<maxVal){
 28 |         tree[idx]+=val;
 29 |         idx+=(idx&-idx);
 30 |     }
 31 | }
 32 | 
 33 | int x[200005],y[200005];
 34 | map<int,int>mx,my;
 35 | 
 36 | vector<pair<int,pair<int,int> > >vert;
 37 | vector<pair<int,pair<int,int> > >Q;
 38 | 
 39 | int main(){
 40 | //    freopen("in.txt","r",stdin);
 41 | //    freopen("out.txt","w",stdout);
 42 | 
 43 |     int n,m;//m consulta  n poligono
 44 |     while(scanf("%d %d",&m,&n)==2){
 45 |         memset(tree,0,sizeof(tree));
 46 |         int a,b;
 47 |         mx.clear();my.clear();
 48 |         int tam=n+m;
 49 |         Q.clear();
 50 |         for(int i=0;i<m;i++){
 51 |             scanf("%d %d",&a,&b);
 52 |             x[i+n]=a;y[i+n]=b;
 53 |             Q.push_back(make_pair(a, make_pair(b,i+1 ) ));
 54 |         }
 55 | 
 56 |         for(int i=0;i<n;i++){
 57 |             scanf("%d %d",&a,&b);
 58 |             x[i]=a;y[i]=b;
 59 |         }
 60 |         
 61 |         vert.clear();
 62 |         
 63 |         for(int i=0;i<n;i++){
 64 |             int x1=x[i];int y1=y[i];
 65 |             int x2=x[(i+1)%n];int y2=y[(i+1)%n];
 66 |             if(x1==x2){
 67 |                 vert.push_back(make_pair(x1,make_pair(min(y1,y2),max(y1,y2))));
 68 |             }
 69 |         }
 70 |         
 71 |         
 72 |         
 73 |         sort(x,x+tam);
 74 |         sort(y,y+tam);
 75 | //////////////COMPRESION DE COORDENADAS//////////////////////
 76 |         mx[x[0]]=1;
 77 |         int val=2;
 78 |         for(int i=1;i<tam;i++)
 79 |             if(x[i]!=x[i-1])
 80 |                 mx[x[i]]=val++;
 81 | 
 82 |         val=3;
 83 |         my[y[0]]=1;
 84 |         for(int i=1;i<tam;i++)
 85 |             if(y[i]!=y[i-1]){
 86 |                 my[y[i]]=val;
 87 |                 val+=2;
 88 |             }
 89 | ///////////////////////////////////7777777777777777777777777777
 90 | 
 91 |         sort(vert.begin(),vert.end());
 92 |         sort(Q.begin(),Q.end());
 93 |         int id=0;
 94 |         long long  sum=0;
 95 | 
 96 |         for(int i=0;i<Q.size();i++){
 97 |             int x1=mx[Q[i].first];
 98 |             int y1=my[Q[i].second.first];
 99 |             int num=Q[i].second.second;
100 |             while(id<vert.size()){
101 |                 int v1=my[vert[id].second.first];
102 |                 int v2=my[vert[id].second.second];
103 |                 int h=mx[vert[id].first];
104 |                 if(h>=x1){
105 |                     int tot=query(y1+1);
106 |                     if(tot%2==0)sum+=num;
107 |                     break;
108 |                 }else{
109 |                     update(v1,1);
110 |                     update(v2+1,-1);
111 |                     id++;
112 |                 }
113 |             }
114 |             
115 |             if(id==vert.size())sum+=num;
116 |         }
117 | 
118 |         cout<<sum<<endl;
119 |     }
120 |     
121 |     return 0;
122 | }
123 | 
124 | 
125 | 


--------------------------------------------------------------------------------
/solucionario regional 2015/h.cpp:
--------------------------------------------------------------------------------
  1 | #include<iostream>
  2 | #include<cstring>
  3 | #include<cstdio>
  4 | #include<algorithm>
  5 | #include<sstream>
  6 | #include<set>
  7 | #include<vector>
  8 | #include<map>
  9 | #include<cassert>
 10 | #include<queue>
 11 | using namespace std;
 12 | int R,C;
 13 | int c[101][101];
 14 | bool visited[101][101];
 15 | int di[4]={-1,1,0,0};
 16 | int dj[4]={0,0,1,-1};
 17 | 
 18 | void dfs(int x, int y){
 19 |     visited[x][y]=1;
 20 |     for(int i=0;i<4;i++){
 21 |         int X=x+di[i];
 22 |         int Y=y+dj[i];
 23 |         if(X>=0 && X<R && Y>=0 && Y<C)
 24 |             if(!visited[X][Y] && c[x][y]==c[X][Y]){
 25 |                 dfs(X,Y);
 26 |             }
 27 |     }
 28 |     return ;
 29 | }
 30 | 
 31 | int main(){
 32 | 
 33 | 
 34 |     while(cin>>R>>C){
 35 |         for(int i=0;i<R;i++)
 36 |             for(int j=0;j<C;j++)
 37 |                 cin>>c[i][j];
 38 |         int dev=5;
 39 |         //cout<<"dev "<<dev<<endl;
 40 |         //parte1
 41 |         for(int i=R-2;i>=0;i--){
 42 |             int ini=0;int fin=0;
 43 |             for(int j=0;j<C;j++){
 44 |                 if(c[i][j]>c[i+1][j]){
 45 |                     if(c[i][j]<=ini || c[i+1][j]>=fin){
 46 |                         dev++;
 47 |                     }
 48 |                     ini=c[i+1][j];
 49 |                     fin=c[i][j];
 50 |                 }else{
 51 |                     ini=0;fin=0;
 52 |                 }
 53 |             }
 54 |         }
 55 |         
 56 |         //cout<<"dev "<<dev<<endl;
 57 |         //parte2
 58 |         for(int i=1;i<R;i++){
 59 |             int ini=0;int fin=0;
 60 |             for(int j=0;j<C;j++){
 61 |                 if(c[i][j]>c[i-1][j]){
 62 |                     if(c[i][j]<=ini || c[i-1][j]>=fin){
 63 |                         dev++;
 64 |                     }
 65 |                     ini=c[i-1][j];
 66 |                     fin=c[i][j];
 67 |                 }else{
 68 |                     ini=0;fin=0;
 69 |                 }
 70 |             }
 71 |         }
 72 | 
 73 |         //cout<<"dev "<<dev<<endl;
 74 |         //parte3
 75 |         for(int j=C-2;j>=0;j--){
 76 |             int ini=0;int fin=0;
 77 |             for(int i=0;i<R;i++){
 78 |                 if(c[i][j]>c[i][j+1]){
 79 |                     if(c[i][j]<=ini || c[i][j+1]>=fin){
 80 |                         dev++;
 81 |                     }
 82 |                     ini=c[i][j+1];
 83 |                     fin=c[i][j];
 84 |                 }else{
 85 |                     ini=0;fin=0;
 86 |                 }
 87 |             }
 88 |         }
 89 | 
 90 |         //cout<<"dev "<<dev<<endl;
 91 |         //parte4
 92 |         for(int j=1;j<C;j++){
 93 |             int ini=0;int fin=0;
 94 |             for(int i=0;i<R;i++){
 95 |                 if(c[i][j]>c[i][j-1]){
 96 |                     if(c[i][j]<=ini || c[i][j-1]>=fin){
 97 |                         dev++;
 98 |                     }
 99 |                     ini=c[i][j-1];
100 |                     fin=c[i][j];
101 |                 }else{
102 |                     ini=0;fin=0;
103 |                 }
104 |             }
105 |         }
106 | 
107 |         memset(visited,0,sizeof(visited));
108 |         //cout<<"dev "<<dev<<endl;
109 |         for(int i=0;i<R;i++)
110 |             for(int j=0;j<C;j++)
111 |                 if(!visited[i][j]){
112 |                     dev++;
113 |                     dfs(i,j);
114 |                 }
115 |         
116 |         cout<<dev<<endl;
117 |     }
118 | 
119 |     return 0;
120 | }
121 | 
122 | 


--------------------------------------------------------------------------------
/solucionario regional 2017/i.cpp:
--------------------------------------------------------------------------------
  1 | #include<iostream>
  2 | #include<cstring>
  3 | #include<map>
  4 | #include<cstdio>
  5 | #include<vector>
  6 | #include<cmath>
  7 | #include<sstream>
  8 | #include<algorithm>
  9 | #include<set>
 10 | #include<queue>
 11 | #define MOD 1000000007LL
 12 | #define MAX 100005
 13 | using namespace std;
 14 | 
 15 | int uf[MAX];
 16 | int FIND(int x){ return uf[x]==x? x:uf[x] = FIND(uf[x]); }
 17 | void UNION(int x,int y){ uf[FIND(x)] = FIND(y); }
 18 | 
 19 | struct node{
 20 | 	int u,v,d;
 21 | 	
 22 | 	node(int _u,int _v,int _d){
 23 | 		u=_u;v=_v;d=_d;
 24 | 	}
 25 | 	
 26 | 	node(){}	
 27 | };
 28 | 
 29 | bool operator<(node a,node b){
 30 | 	if(a.d!=b.d)return a.d<b.d;
 31 | 	if(a.u!=b.u)return a.u<b.u;
 32 | 	return a.v<b.v;
 33 | }
 34 | 
 35 | int n,e;//nodes and edges
 36 | vector<pair<int,int> >adj[100005];
 37 | 
 38 | int papi[100005];
 39 | bool visited[100005];
 40 | int L[100005];
 41 | int M[100005];
 42 | int Maximo[100005][18];
 43 | int P[100005][18];
 44 | 
 45 | void getArbol(int node,int niv){
 46 |     visited[node]=1;
 47 |     L[node]=niv;
 48 |     
 49 |     for(int i=0;i<adj[node].size();i++){
 50 |         if(!visited[adj[node][i].first]){
 51 |         	M[adj[node][i].first]=adj[node][i].second;
 52 |             papi[adj[node][i].first]=node;
 53 |             getArbol(adj[node][i].first,niv+1);     
 54 |         }
 55 |     }
 56 | }
 57 | 
 58 | void getPapi(){
 59 |     memset(P,-1,sizeof(P));
 60 |     //memset(Maximo,-1,sizeof(Maximo));
 61 |     
 62 | 	for(int i=0;i<n;i++)P[i][0]=papi[i];
 63 |     for(int i=0;i<n;i++)Maximo[i][0]=M[i];
 64 |     
 65 |     
 66 |     for(int j=1;(1<<j)<n;j++)
 67 |         for(int i=1;i<n;i++)
 68 |             if(P[i][j-1]!=-1){
 69 |                 P[i][j]=P[P[i][j-1]][j-1];		
 70 | 				Maximo[i][j]=max(Maximo[i][j-1],  Maximo[P[i][j-1]][j-1]);
 71 | 			}	
 72 |     return ;      
 73 | }
 74 | 
 75 | int LCA(int a,int b){
 76 |     if(L[a]<L[b])swap(a,b);
 77 |     
 78 |     for(int i=16;i>=0;i--)
 79 |         if(L[a]-(1<<i)>=L[b] )
 80 |             a=P[a][i];    
 81 |     
 82 |     if(a==b)return b;
 83 |     
 84 |     for(int i=16;i>=0;i--)
 85 |         if(P[a][i]!= P[b][i]){
 86 |             a=P[a][i];
 87 |             b=P[b][i];    
 88 |         }
 89 |     
 90 |     return papi[a];
 91 | }
 92 | 
 93 | int maxim(int a,int b){  //L[b]<=L[a]
 94 | 	int dif=L[a]-L[b];
 95 | 	int dev=0;
 96 | 	
 97 | 	for(int i=16;i>=0;i--)
 98 |     	if(L[a]-L[b]>=(1<<i)){
 99 |     		dev=max(dev,Maximo[a][i]);
100 | 			a=P[a][i];
101 | 		}
102 | 	return dev;
103 | }
104 | 
105 | int main(){
106 | 	//freopen("in.txt","r",stdin);
107 | 	//freopen("out.txt","w",stdout);
108 | 	
109 | 	while(cin>>n>>e){
110 | 		for(int i=0;i<n;i++)if(adj[i].size()>0)adj[i].clear();
111 | 		for(int i=0;i<n;i++)uf[i]=i;
112 | 		
113 | 		vector<node>v;
114 | 		map<pair<int,int>,int>m;
115 | 		int sum=0;
116 | 		
117 | 		for(int i=0;i<e;i++){
118 | 			int a,b,d;
119 | 			scanf("%d %d %d",&a,&b,&d);
120 | 			a--;b--;
121 | 			v.push_back(node(a,b,d));
122 | 			m[make_pair(min(a,b),max(a,b))]=d;
123 | 		}
124 | 		
125 | 		sort(v.begin(),v.end());
126 | 		
127 | 		for(int i=0;i<e;i++){
128 | 			if(FIND(v[i].u)!=FIND(v[i].v)){
129 | 				UNION(v[i].u,v[i].v);
130 | 				adj[v[i].u].push_back(make_pair(v[i].v,v[i].d));
131 | 				adj[v[i].v].push_back(make_pair(v[i].u,v[i].d));
132 | 				sum+=v[i].d;
133 | 			}
134 | 		}
135 | 		
136 | 		memset(visited,0,sizeof(visited));
137 |         memset(papi,-1,sizeof(papi));
138 |         memset(M,0,sizeof(M));
139 |         
140 |         getArbol(0,0);
141 |         getPapi();
142 | 		
143 | 		
144 | 		int q;
145 | 		scanf("%d",&q);
146 | 		
147 | 		for(int i=0;i<q;i++){
148 | 			int a,b;	
149 | 			scanf("%d %d",&a,&b);
150 | 			a--;b--;
151 | 			int x=LCA(a,b);
152 | 			int value=m[make_pair(min(a,b),max(a,b))];
153 | 			printf("%d\n" , sum+value-max( maxim(a,x),maxim(b,x) ));
154 | 		}
155 | 	}
156 | 	
157 | 	
158 | 	return 0;
159 | }
160 | 


--------------------------------------------------------------------------------
/Solucionario regional 2019/D.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <cstring>
  3 | #include <cmath>
  4 | #include <map>
  5 | #include <vector>
  6 | #include <string>
  7 | #include <algorithm>
  8 | #include <set>
  9 | #include <map>
 10 | #include <unordered_map>
 11 | using namespace std;
 12 | 
 13 | //dot product
 14 | int area(pair<int,int>a,pair<int,int>b,pair<int,int>c){
 15 | 	int x1 = b.first - a.first;
 16 | 	int y1 = b.second - a.second;
 17 | 	
 18 | 	int x2 = c.first - a.first;
 19 | 	int y2 = c.second -a.second;
 20 | 	
 21 | 	return x1*y2 -x2*y1;
 22 | }
 23 | 
 24 | vector<pair<int,int>> ConvexHull(vector <pair<int,int>> &P){
 25 |     sort(P.begin(),P.end());
 26 |     int n = P.size(),k = 0;
 27 |     pair<int,int> H[2*n];
 28 |     
 29 |     for(int i=0;i<n;++i){
 30 |         while(k>=2 && area(H[k-2],H[k-1],P[i]) <0) --k;
 31 |         H[k++] = P[i];
 32 |     }
 33 |     
 34 |     for(int i=n-2,t=k;i>=0;--i){
 35 |         while(k>t && area(H[k-2],H[k-1],P[i]) < 0) --k;
 36 |         H[k++] = P[i];
 37 |     }
 38 |     
 39 |     return vector <pair<int,int>> (H,H+k-1);
 40 | }
 41 | 
 42 | 
 43 | 
 44 | int main() {
 45 | 	int n;	
 46 | 	while(cin>>n){
 47 | 		map< pair<int,int>, int>m;
 48 | 		vector<pair<int,int> >P;
 49 | 		vector<pair<int, pair<int,int> > >ordered;//(bright, x,y)
 50 | 		
 51 | 		
 52 | 		for(int i = 0;i < n; i++){
 53 | 			int x, y, b;
 54 | 			cin>>x>>y>>b;
 55 | 			P.push_back(make_pair(x,y));
 56 | 			m[make_pair(x,y)] = b;
 57 | 			ordered.push_back(make_pair(b,make_pair(x,y)));
 58 | 		}
 59 | 		
 60 | 		sort(ordered.begin(),ordered.end());
 61 | 		vector<pair<int,int> > hull = ConvexHull(P);
 62 | 		
 63 | 		int sizeorder = ordered.size();
 64 | 		n = hull.size();
 65 | 		
 66 | 		if(hull.size()<3){
 67 | 			cout<<"Y"<<endl;
 68 | 			continue;
 69 | 		}
 70 | 		
 71 | 		bool ok = 0;
 72 | 		
 73 | 		for(int i = 0;i< hull.size() && !ok;i++)
 74 | 			for(int j = i + 1;j < hull.size();j++){
 75 | 				int dx = hull[i].first -hull[j].first;
 76 | 				int dy = hull[i].second - hull[j].second;
 77 | 				
 78 | 				int firstval = 1<<30;
 79 | 				
 80 | 				bool increasing = false;
 81 | 				bool yeah = true;
 82 | 				for(int k = 0; k< sizeorder;){
 83 | 					int B = ordered[k].first;
 84 | 					int minimum = 1<<30;
 85 | 					int maximum = -1<<30;
 86 | 					
 87 | 					while(k < sizeorder && ordered[k].first ==B){
 88 | 						int val = ordered[k].second.first*dy -ordered[k].second.second*dx;
 89 | 						minimum = min(minimum, val);
 90 | 						maximum = max(maximum, val);
 91 | 						k++;
 92 | 					}
 93 | 					
 94 | 					if(increasing){
 95 | 						if(minimum < firstval){
 96 | 							yeah = false;
 97 | 							break;
 98 | 						}
 99 | 						firstval = maximum;
100 | 					}else{
101 | 						
102 | 						if(maximum >firstval){
103 | 							yeah = false;
104 | 							break;
105 | 						}
106 | 						firstval =  minimum;
107 | 					}
108 | 					
109 | 				}
110 | 				
111 | 				
112 | 				if(yeah){
113 | 					ok=true;
114 | 					break;
115 | 				}
116 | 				
117 | 				
118 | 				firstval = -1<<30;
119 | 			    increasing = true;
120 | 				yeah = true;
121 | 				for(int k = 0; k < sizeorder;){
122 | 					int B = ordered[k].first;
123 | 					int minimum = 1<<30;
124 | 					int maximum = -1<<30;
125 | 					
126 | 					while(k < sizeorder && ordered[k].first ==B){
127 | 						int val = ordered[k].second.first*dy -ordered[k].second.second*dx;
128 | 						minimum = min(minimum, val);
129 | 						maximum = max(maximum, val);
130 | 						k++;
131 | 					}
132 | 					
133 | 					if(increasing){
134 | 						if(minimum < firstval){
135 | 							yeah = false;
136 | 							break;
137 | 						}
138 | 						firstval = maximum;
139 | 					}else{
140 | 						
141 | 						if(maximum >firstval){
142 | 							yeah = false;
143 | 							break;
144 | 						}
145 | 						firstval =  minimum;
146 | 					}	
147 | 				}
148 | 				
149 | 				if(yeah){
150 | 					ok=true;
151 | 					break;
152 | 				}
153 | 			}
154 | 		
155 | 		if(ok){
156 | 			cout<<"Y"<<endl;
157 | 		}else{
158 | 			cout<<"N"<<endl;
159 | 		}
160 | 		
161 | 	}
162 | 	
163 | 	
164 | 		
165 | 	return 0;
166 | }
167 | 


--------------------------------------------------------------------------------
/solucionario regional 2017/a.cpp:
--------------------------------------------------------------------------------
  1 | #include<iostream>
  2 | #include<cstring>
  3 | #include<cstdio>
  4 | #include<vector>
  5 | #include<cmath>
  6 | #include<sstream>
  7 | #include<algorithm>
  8 | #include<set>
  9 | #include<queue>
 10 | #define EPS 1e-8
 11 | using namespace std;
 12 | vector<pair<int,int> >v[15];
 13 | int h;
 14 | double dis[15][15];
 15 | int n;
 16 | 
 17 | inline bool area(pair<double,double> A, pair<double,double> B,pair<double,double> C) {	
 18 | 	if( (B.first-A.first)*(C.second-A.second)>(B.second-A.second)* (C.first-A.first) )return 1;
 19 | 	return 0;	
 20 | }
 21 | 
 22 | 
 23 | inline bool intersecta(pair<double,double> P1,pair<double,double> P2,pair<double,double>P3, pair<double,double>P4){
 24 | 	bool A1 = area(P3, P4, P1);
 25 |     bool A2 = area(P3, P4, P2);
 26 |     bool A3 = area(P1, P2, P3);
 27 |     bool A4 = area(P1, P2, P4);
 28 |     
 29 | 	if( ( ( A1 && !A2  ) || ( !A1  && A2) ) && 
 30 | 		( ( A3 && !A4  ) || ( !A3  && A4 ) ) ) return 1;
 31 |             
 32 | 	return false;
 33 | }
 34 | 
 35 | double f(int id1,int id2){
 36 | 	vector<pair<int,int> >a=v[id1];//polygon 1
 37 | 	vector<pair<int,int> >b=v[id2];//polygon 2
 38 | 	
 39 | 	double lo=a[1].first-a[0].first;double hi=2*1e+8;
 40 | 	int tam1=a.size();
 41 | 	int tam2=b.size();
 42 | 	
 43 | 	for(int caso=0;caso<50;caso++){
 44 | 		double me=(lo+hi)/2;
 45 | 		int pos1=1;// right
 46 | 		int pos2=0;// left
 47 | 					
 48 | 		bool ok=1;
 49 | 		bool fin=0;
 50 | 		while(true){
 51 | 			if(fin)break;
 52 | 			int x1=a[pos1].first;
 53 | 			int y1=a[pos1].second;
 54 | 			int x2=a[(pos1+1)%tam1].first;
 55 | 			int y2=a[(pos1+1)%tam1].second;
 56 | 			
 57 | 			int X1=b[pos2].first;
 58 | 			int Y1=b[pos2].second;
 59 | 			int X2=b[(pos2+tam2-1)%tam2].first;
 60 | 			int Y2=b[(pos2+tam2-1)%tam2].second;
 61 | 			
 62 | 			if(y2==h && Y2==h){
 63 | 				fin=1;
 64 | 			}			
 65 | 			
 66 | 			if(Y1>y2){
 67 | 				pos1++;
 68 | 				continue;
 69 | 			}
 70 | 			
 71 | 			if(y1>Y2){
 72 | 				pos2=(pos2+tam2-1)%tam2;
 73 | 				continue;
 74 | 			}else{
 75 | 				
 76 | 				if(intersecta( make_pair(x1,y1),make_pair(x2,y2) ,make_pair(X1+me,Y1) ,make_pair(X2+me,Y2) )){
 77 | 					ok=0;
 78 | 					break;
 79 | 				}else{	
 80 | 					if(y2>Y2){
 81 | 						pos2=(pos2+tam2-1)%tam2;
 82 | 					}else{
 83 | 						pos1++;		
 84 | 					}
 85 | 				
 86 | 				}
 87 | 				
 88 | 			}
 89 | 						
 90 | 		}	
 91 | 		
 92 | 		
 93 | 		if(ok==0){
 94 | 			lo=me;
 95 | 		}else{
 96 | 			hi=me;
 97 | 		}
 98 | 			
 99 | 	}
100 | 	
101 | 	return hi;
102 | }
103 | 
104 | bool done[1<<15][15];
105 | double memo[1<<15][15];
106 | int g[15];
107 | 
108 | double dp(int mask,int last){
109 | 	if(__builtin_popcount(mask)==n){
110 | 		return g[last];	
111 | 	}
112 | 	
113 | 	if(done[mask][last])return memo[mask][last];
114 | 	double dev=1e+12;
115 | 	
116 | 	for(int i=0;i<n;i++)
117 | 		if( (mask&(1<<i))==0){
118 | 			dev=min(dev, dis[last][i]+dp(mask|(1<<i),i  )  );
119 | 		}
120 | 	
121 | 	
122 | 	memo[mask][last]=dev;
123 | 	done[mask][last]=1;
124 | 	return dev;
125 | }
126 | 
127 | int main(){
128 | 	//freopen("in.txt","r",stdin);
129 | 	//freopen("out.txt","w",stdout);
130 | 	
131 | 	
132 | 	while(cin>>n){
133 | 		//cout<<"n "<<n<<endl;
134 | 		for(int i=0;i<n;i++)v[i].clear();
135 | 		h=0;
136 | 		
137 | 		for(int i=0;i<n;i++){
138 | 			vector<pair<int,int> >x;
139 | 			int size;
140 | 			scanf("%d",&size);	
141 | 			//cout<<"size "<<size<<endl;
142 | 			g[i]=0;
143 | 			
144 | 			for(int j=0;j<size;j++){
145 | 				int a,b;
146 | 				scanf("%d %d",&a,&b);
147 | 				//cout<<"j "<<a<<" "<<b<<endl;
148 | 				x.push_back(make_pair(a,b));
149 | 				h=max(h,b);
150 | 				g[i]=max(g[i],a);
151 | 			}
152 | 			
153 | 			v[i]=x;
154 | 		}
155 | 		
156 | 		for(int i=0;i<n;i++)
157 | 			for(int j=0;j<n;j++){
158 | 				if(i==j)continue;
159 | 				dis[i][j]=f(i,j);
160 | 				//cout<<i<<" "<<j<<" "<<dis[i][j]<<endl;
161 | 			}
162 | 		
163 | 		memset(done,0,sizeof(done));
164 | 		double dev=1e+21;
165 | 		
166 | 		for(int i=0;i<n;i++){
167 | 			double w=0;
168 | 			for(int j=0;j<v[i].size();j++)
169 | 				if(v[i][j].first<0)w=max(w,abs(v[i][j].first)+0.0);
170 | 			
171 | 			
172 | 			dev=min(dev,w+dp(1<<i,i) );
173 | 		}
174 | 		
175 | 		
176 | 		printf("%.3lf\n",dev);
177 | 			
178 | 	}
179 | 		
180 | 	return 0;
181 | }
182 | 
183 | 
184 | 


--------------------------------------------------------------------------------
/solucionario regional 2015/e2.cpp:
--------------------------------------------------------------------------------
  1 | #include<iostream>
  2 | #include<cstring>
  3 | #include<cstdio>
  4 | #include<algorithm>
  5 | #include<sstream>
  6 | #include<set>
  7 | #include<vector>
  8 | #include<map>
  9 | #include<cassert>
 10 | #include<queue>
 11 | using namespace std;
 12 | int a[101],b[101];
 13 | vector<int>v1[101];
 14 | vector<int>v2[101];
 15 | bool visitedL[101];
 16 | bool visitedR[101];
 17 | set<int>L,R;
 18 | int memo[101][10005];
 19 | vector<int>tam,cost;
 20 | int n,m,r,c;
 21 | 
 22 | void dfs(int t,bool izq){
 23 |     if(izq){
 24 |         visitedL[t]=1;
 25 |         L.insert(t);
 26 |         for(int i=0;i<v1[t].size();i++){
 27 |             if(!visitedR[v1[t][i]]){
 28 |                 dfs(v1[t][i],!izq);
 29 |             }
 30 |         }
 31 |     }else{
 32 |         visitedR[t]=1;
 33 |         R.insert(t);
 34 |         for(int i=0;i<v2[t].size();i++){
 35 |             if(!visitedL[v2[t][i]]){
 36 |                 dfs(v2[t][i],!izq);
 37 |             }
 38 |         }
 39 |     }
 40 |     return ;
 41 | }
 42 | 
 43 | int dp(int pos,int ac){
 44 |     if(pos==-1)return 0;
 45 |     if(memo[pos][ac]!=-1)return memo[pos][ac];
 46 |     int dev=dp(pos-1,ac);
 47 |     if(ac+cost[pos]<=c )
 48 |         dev=max(dev, tam[pos]+dp(pos-1,ac+cost[pos])  );
 49 |     memo[pos][ac]=dev;
 50 |     return dev;
 51 | }
 52 | 
 53 | 
 54 | int main(){
 55 | 
 56 |     
 57 |     while(cin>>n>>m>>r>>c){
 58 |         for(int i=0;i<101;i++){v1[i].clear();v2[i].clear();}
 59 |         for(int i=0;i<n;i++)cin>>a[i];
 60 |         for(int i=0;i<m;i++)cin>>b[i];
 61 |         for(int i=0;i<r;i++){
 62 |             int p,q;
 63 |             cin>>p>>q;
 64 |             p--;q--;
 65 |             v1[p].push_back(q);
 66 |             v2[q].push_back(p);
 67 |         }
 68 | 
 69 |         memset(visitedL,0,sizeof(visitedL));
 70 |         memset(visitedR,0,sizeof(visitedR));
 71 |         tam.clear();cost.clear();
 72 |         
 73 |         for(int i=0;i<n;i++){
 74 |             if(!visitedL[i]){
 75 |                 L.clear();R.clear();
 76 |                 dfs(i,1);
 77 |                 if(R.size()<L.size()){
 78 |                     vector<int>nodoizq(L.begin(),L.end());
 79 |                     vector<int>nododer(R.begin(),R.end());
 80 |                     int sumcost=0;
 81 |                     for(int j=0;j<nodoizq.size();j++)
 82 |                         sumcost+= a[nodoizq[j]];
 83 |                     for(int j=0;j<nododer.size();j++)
 84 |                         sumcost+= b[nododer[j]];
 85 |                     tam.push_back(L.size()-(int)R.size());
 86 |                     cost.push_back(sumcost);
 87 |                 }
 88 |             }
 89 |         }
 90 |         
 91 |         memset(memo,-1,sizeof(memo));
 92 |         int dev1=m;
 93 |         if(tam.size()>0)
 94 |             dev1+=dp(tam.size()-1,0);
 95 |         /*
 96 |         cout<<"x ";
 97 |         for(int i=0;i<tam.size();i++)cout<<tam[i]<<" ";
 98 |         cout<<endl;
 99 |         cout<<"x ";
100 |         for(int i=0;i<cost.size();i++)cout<<cost[i]<<" ";
101 |         cout<<endl;
102 |         */
103 |         
104 |         tam.clear();cost.clear();
105 |         memset(memo,-1,sizeof(memo));
106 |         memset(visitedL,0,sizeof(visitedL));
107 |         memset(visitedR,0,sizeof(visitedR));
108 | 
109 |         for(int i=0;i<m;i++){
110 |             if(!visitedR[i]){
111 |                 L.clear();R.clear();
112 |                 dfs(i,0);
113 |                 if(R.size()>L.size()){
114 |                     vector<int>nodoizq(L.begin(),L.end());
115 |                     vector<int>nododer(R.begin(),R.end());
116 |                     int sumcost=0;
117 |                     for(int j=0;j<nodoizq.size();j++)
118 |                         sumcost+= a[nodoizq[j]];
119 |                     for(int j=0;j<nododer.size();j++)
120 |                         sumcost+= b[nododer[j]];
121 |                     tam.push_back(R.size()-(int)L.size());
122 |                     cost.push_back(sumcost);
123 |                 }
124 |             }
125 |         }
126 | 
127 |         /*
128 |         cout<<"x ";
129 |         for(int i=0;i<tam.size();i++)cout<<tam[i]<<" ";
130 |         cout<<endl;
131 |         cout<<"x ";
132 |         for(int i=0;i<cost.size();i++)cout<<cost[i]<<" ";
133 |         cout<<endl;
134 |         */
135 |         int dev2=n;
136 |         if(tam.size()>0)
137 |             dev2+=dp(tam.size()-1,0);
138 | 
139 |         cout<<dev2<<" "<<dev1<<endl;
140 |     }
141 |     
142 |     return 0;
143 | }
144 | 
145 | 


--------------------------------------------------------------------------------
/solucionario regional 2017/k.cpp:
--------------------------------------------------------------------------------
  1 | #include<iostream>
  2 | #include<cstring>
  3 | #include<cstdio>
  4 | #include<vector>
  5 | #include<cmath>
  6 | #include<sstream>
  7 | #include<algorithm>
  8 | #include<set>
  9 | #include<queue>
 10 | #define EPS 1e-8
 11 | using namespace std;
 12 | int R,C;
 13 | char c[21][21];
 14 | 
 15 | #define MAXN 1001
 16 | #define INF (1<<28)
 17 |   
 18 | vector <int> adj[MAXN + 1]; // (u, v) <=> (v, u)
 19 | int n, m, NIL, match[MAXN + 1], dist[MAXN + 1];
 20 | // Izquierda; nodos del 0 al n-1
 21 | // Derecha: Nodos del n al n+m-1
 22 | // NIL: Nodo n+m
 23 | 
 24 |   
 25 | bool bfs(){
 26 |     queue <int> Q;
 27 |     for(int i=0; i<n; i++) {
 28 |         if(match[i] == NIL) {
 29 |             dist[i] = 0;
 30 |             Q.push(i);
 31 |         }
 32 |         else dist[i] = INF;
 33 |     }
 34 |     dist[NIL] = INF;
 35 |       
 36 |     while(!Q.empty()) {
 37 |         int u = Q.front(); Q.pop();
 38 |         for(int i=0; i<adj[u].size(); i++){
 39 |             int v = adj[u][i];
 40 |             if(dist[match[v]] == INF) {
 41 |                 dist[match[v]] = dist[u] + 1;
 42 |                 Q.push(match[v]);
 43 |             }
 44 |         }
 45 |     }
 46 |     return dist[NIL] != INF;
 47 | }
 48 |   
 49 | bool dfs(int u) {
 50 |     if(u != NIL) {
 51 |         for(int i=0; i<adj[u].size(); i++) {
 52 |             int v = adj[u][i];
 53 |             if(dist[match[v]] == dist[u] + 1) {
 54 |                 if(dfs(match[v])) {
 55 |                     
 56 |                     match[v] = u;
 57 |                     match[u] = v;
 58 |                     return true;
 59 |                 }
 60 |             }
 61 |         }
 62 |         dist[u] = INF;
 63 |         return false;
 64 |     }
 65 |     return true;
 66 | }
 67 |   
 68 | int hopcroft_karp(){
 69 |     NIL = n + m;
 70 |     for(int i=0; i<n+m; i++)
 71 |         match[i] = NIL;
 72 |       
 73 |     int matching = 0;
 74 |       
 75 |     //Greedy Step
 76 |     for(int u=0; u<n; u++){
 77 |         for(int i=0; i<adj[u].size(); i++){
 78 |             int v = adj[u][i];
 79 |             if(match[v] == NIL){
 80 |                 matching++;
 81 |                 match[u] = v;
 82 |                 match[v] = u;
 83 |                 break;
 84 |             }
 85 |         }
 86 |     }
 87 |       
 88 |     while(bfs())
 89 |         for(int u=0; u<n; u++)
 90 |             if(match[u] == NIL && dfs(u))
 91 |                 matching++;
 92 |     
 93 |     return matching;
 94 | }
 95 | 
 96 | 
 97 | int node[21][21];
 98 | int size[21][21];
 99 | 
100 | int main(){
101 | 	//freopen("in.txt","r",stdin);
102 | 	//freopen("out.txt","w",stdout);
103 | 	
104 | 	while(cin>>R>>C){
105 | 		for(int i=0;i<MAXN;i++)adj[i].clear();
106 | 		int o=0;
107 | 		
108 | 		
109 | 		for(int i=0;i<R;i++)
110 | 			for(int j=0;j<C;j++){
111 | 				cin>>c[i][j];
112 | 				if(c[i][j]=='o')o++;
113 | 			}
114 | 		
115 | 		if(o%2==1){
116 | 			cout<<"N"<<endl;
117 | 			continue;
118 | 		}
119 | 		
120 | 		n=0;
121 | 		int lasteven=0;
122 | 		int lastodd=0;
123 | 				
124 | 		for(int i=0;i<R;i++)
125 | 			for(int j=0;j<C;j++){
126 | 				if( (i+j)%2==0 ){
127 | 					if(c[i][j]=='o'){
128 | 						node[i][j]=lasteven+1;
129 | 						size[i][j]=1;
130 | 					}else{
131 | 						node[i][j]=lasteven+2;
132 | 						size[i][j]=2;
133 | 					}
134 | 					lasteven=node[i][j];
135 | 				}else{
136 | 					if(c[i][j]=='o'){
137 | 						node[i][j]=lastodd+1;
138 | 						size[i][j]=1;
139 | 					}else{
140 | 						node[i][j]=lastodd+2;
141 | 						size[i][j]=2;
142 | 					}
143 | 					lastodd=node[i][j];
144 | 				}
145 | 				
146 | 			}
147 | 		
148 | 		n=lasteven;
149 | 		m=lastodd;
150 | 		NIL=n+m;
151 | 		
152 | 		int di[4]={-1,1,0,0};
153 | 		int dj[4]={0,0,1,-1};
154 | 		
155 | 		for(int i=0;i<R;i++)
156 | 			for(int j=0;j<C;j++){
157 | 				if( (i+j)%2==1)continue;
158 | 				
159 | 				//4 directions
160 | 				for(int k=0;k<4;k++){
161 | 					int x=i+di[k];
162 | 					int y=j+dj[k];
163 | 					if(x>=0 && x<R &&y>=0 && y<C){
164 | 						int start1=node[i][j]-size[i][j];
165 | 						int end1=node[i][j];
166 | 						
167 | 						int start2=node[x][y]-size[x][y];
168 | 						int end2=node[x][y];
169 | 						
170 | 						for(int ii=start1;ii<end1;ii++)
171 | 							for(int jj=start2;jj<end2;jj++)
172 | 								adj[ii].push_back(n+jj);
173 | 					}
174 | 				}
175 | 				
176 | 			}
177 | 		
178 | 		if(hopcroft_karp()==NIL/2){
179 | 			cout<<"Y"<<endl;
180 | 		}else{
181 | 			cout<<"N"<<endl;
182 | 		}
183 | 		
184 | 	}
185 | 	
186 | 			
187 | 	return 0;
188 | }
189 | 
190 | 
191 | 


--------------------------------------------------------------------------------
/solucionario regional 2013/a.cpp:
--------------------------------------------------------------------------------
  1 | #include <vector>
  2 | #include <list>
  3 | #include <map>
  4 | #include <set>
  5 | #include <queue>
  6 | #include <deque>
  7 | #include <stack>
  8 | #include <bitset>
  9 | #include <algorithm>
 10 | #include <functional>
 11 | #include <numeric>
 12 | #include <utility>
 13 | #include <sstream>
 14 | #include <iostream>
 15 | #include <iomanip>
 16 | #include <cstdio>
 17 | #include <cmath>
 18 | #include <cstdlib>
 19 | #include <ctime>
 20 | #include <string.h>
 21 | #include <stdio.h>
 22 | #define all(v) (v).begin(),(v).end()
 23 | #define rall(v) (v).rbegin(),(v).rend()
 24 | using namespace std;  // H A M L E T
 25 | #define MAXN 10001
 26 | #define INF (1<<28)
 27 |   
 28 | vector <int> adj[MAXN + 1]; // (u, v) <=> (v, u)
 29 | int n, m, NIL, match[MAXN + 1], dist[MAXN + 1];
 30 | // Izquierda; nodos del 0 al n-1
 31 | // Derecha: Nodos del n al n+m-1
 32 | // NIL: Nodo n+m
 33 | 
 34 | int R,C;  
 35 |   
 36 | bool bfs(){
 37 |     queue <int> Q;
 38 |     for(int i=0; i<n; i++) {
 39 |         if(match[i] == NIL) {
 40 |             dist[i] = 0;
 41 |             Q.push(i);
 42 |         }
 43 |         else dist[i] = INF;
 44 |     }
 45 |     dist[NIL] = INF;
 46 |       
 47 |     while(!Q.empty()) {
 48 |         int u = Q.front(); Q.pop();
 49 |         for(int i=0; i<adj[u].size(); i++){
 50 |             int v = adj[u][i];
 51 |             if(dist[match[v]] == INF) {
 52 |                 dist[match[v]] = dist[u] + 1;
 53 |                 Q.push(match[v]);
 54 |             }
 55 |         }
 56 |     }
 57 |     return dist[NIL] != INF;
 58 | }
 59 |   
 60 | bool dfs(int u) {
 61 |     if(u != NIL) {
 62 |         for(int i=0; i<adj[u].size(); i++) {
 63 |             int v = adj[u][i];
 64 |             if(dist[match[v]] == dist[u] + 1) {
 65 |                 if(dfs(match[v])) {
 66 |                     
 67 |                     match[v] = u;
 68 |                     match[u] = v;
 69 |                     return true;
 70 |                 }
 71 |             }
 72 |         }
 73 |         dist[u] = INF;
 74 |         return false;
 75 |     }
 76 |     return true;
 77 | }
 78 |   
 79 | int hopcroft_karp(){
 80 |     NIL = n + m;
 81 |     for(int i=0; i<n+m; i++)
 82 |         match[i] = NIL;
 83 |       
 84 |     int matching = 0;
 85 |       
 86 |     //Greedy Step
 87 |     for(int u=0; u<n; u++){
 88 |         for(int i=0; i<adj[u].size(); i++){
 89 |             int v = adj[u][i];
 90 |             if(match[v] == NIL){
 91 |                 matching++;
 92 |                 match[u] = v;
 93 |                 match[v] = u;
 94 |                 break;
 95 |             }
 96 |         }
 97 |     }
 98 |       
 99 |     while(bfs())
100 |         for(int u=0; u<n; u++)
101 |             if(match[u] == NIL && dfs(u))
102 |                 matching++;
103 |     
104 |     return matching;
105 | }
106 | 
107 | int main(){
108 |     
109 |     int tam;
110 |     while(cin>>tam){
111 |         for(int i=0;i<MAXN;i++)
112 |             if(adj[i].size()>0)
113 |                 adj[i].clear();
114 |         
115 |         char c[tam][tam];
116 |         
117 |         for(int i=0;i<tam;i++)
118 |             for(int j=0;j<tam;j++)
119 |                 cin>>c[i][j];
120 |         
121 |         n=0;m=0;
122 |         int Filas[tam][tam];
123 |         int Columnas[tam][tam];
124 |         memset(Filas,-1,sizeof(Filas));
125 |         memset(Columnas,-1,sizeof(Columnas));
126 |         
127 |         for(int i=0;i<tam;i++)
128 |             for(int j=0;j<tam;j++)
129 |                 if(c[i][j]=='.'){
130 |                     while(j<tam && c[i][j]=='.'){
131 |                         Filas[i][j]=n;
132 |                         j++;    
133 |                     }
134 |                     n++;
135 |                 }
136 |         
137 |         bool visited[tam][tam];
138 |         memset(visited,0,sizeof(visited));
139 |         
140 |         for(int i=0;i<tam;i++)
141 |             for(int j=0;j<tam;j++)
142 |                 if(c[i][j]=='.' && !visited[i][j]){
143 |                     int id=i;
144 |                     while(id<tam && c[id][j]=='.'){
145 |                         Columnas[id][j]=m;
146 |                         visited[id][j]=1;
147 |                         id++;    
148 |                     }
149 |                     m++;
150 |                 }
151 |         
152 |         for(int i=0;i<tam;i++)
153 |             for(int j=0;j<tam;j++){
154 |                 if(c[i][j]=='.'){
155 |                     adj[Filas[i][j]].push_back(n+Columnas[i][j]);
156 |                 }    
157 |             }
158 |         
159 |         cout<<hopcroft_karp()<<endl;
160 |     }
161 |     
162 |     
163 |     return 0;
164 | }
165 | 


--------------------------------------------------------------------------------
/Solucionario regional 2019/A.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <cstring>
  3 | #include <cmath>
  4 | #include <map>
  5 | #include <vector>
  6 | #include <string>
  7 | #include <algorithm>
  8 | #include <set>
  9 | #include <map>
 10 | #include <queue>
 11 | using namespace std;
 12 | #define MAXN 204805
 13 | #define INF (1<<28)
 14 | vector <int> adj[MAXN + 1]; // (u, v) <=> (v, u)
 15 | map<vector<int>,int>encode;
 16 | int n, m, NIL, match[MAXN + 1], dist[MAXN + 1];
 17 | // Izquierda; nodos del 0 al n-1
 18 | // Derecha: Nodos del n al n+m-1
 19 | // NIL: Nodo n+m
 20 | 
 21 | int R,C;  
 22 |   
 23 | bool bfs(){
 24 |     queue <int> Q;
 25 |     for(int i=0; i<n; i++) {
 26 |         if(match[i] == NIL) {
 27 |             dist[i] = 0;
 28 |             Q.push(i);
 29 |         }
 30 |         else dist[i] = INF;
 31 |     }
 32 |     dist[NIL] = INF;
 33 |       
 34 |     while(!Q.empty()) {
 35 |         int u = Q.front(); Q.pop();
 36 |         for(int i=0; i<adj[u].size(); i++){
 37 |             int v = adj[u][i];
 38 |             if(dist[match[v]] == INF) {
 39 |                 dist[match[v]] = dist[u] + 1;
 40 |                 Q.push(match[v]);
 41 |             }
 42 |         }
 43 |     }
 44 |     return dist[NIL] != INF;
 45 | }
 46 |   
 47 | bool dfs(int u) {
 48 |     if(u != NIL) {
 49 |         for(int i=0; i<adj[u].size(); i++) {
 50 |             int v = adj[u][i];
 51 |             if(dist[match[v]] == dist[u] + 1) {
 52 |                 if(dfs(match[v])) {
 53 |                     
 54 |                     match[v] = u;
 55 |                     match[u] = v;
 56 |                     return true;
 57 |                 }
 58 |             }
 59 |         }
 60 |         dist[u] = INF;
 61 |         return false;
 62 |     }
 63 |     return true;
 64 | }
 65 |   
 66 | int hopcroft_karp(){
 67 |     NIL = n + m;
 68 |     for(int i=0; i<n+m; i++)
 69 |         match[i] = NIL;
 70 |       
 71 |     int matching = 0;
 72 |       
 73 |     //Greedy Step
 74 |     for(int u=0; u<n; u++){
 75 |         for(int i=0; i<adj[u].size(); i++){
 76 |             int v = adj[u][i];
 77 |             if(match[v] == NIL){
 78 |                 matching++;
 79 |                 match[u] = v;
 80 |                 match[v] = u;
 81 |                 break;
 82 |             }
 83 |         }
 84 |     }
 85 |       
 86 |     while(bfs())
 87 |         for(int u=0; u<n; u++)
 88 |             if(match[u] == NIL && dfs(u))
 89 |                 matching++;
 90 |     
 91 |     return matching;
 92 | }
 93 | 
 94 | 
 95 | //Solution
 96 | // Direct application of Maximal antichain
 97 | // Dilworth's Theorem
 98 | // Bipartite matching, hopcroft karp
 99 | //read https://codeforces.com/blog/entry/3781
100 | 
101 | //Practice with https://www.spoj.com/problems/DIVREL/
102 | 
103 | int main() {
104 | 	int N;
105 | 	
106 | 	while(cin>>N){
107 | 		for(int i=0;i<MAXN;i++)
108 |             if(adj[i].size()>0)
109 |                 adj[i].clear();
110 |         
111 | 		encode.clear();        
112 | 		        
113 | 		map<string,int>name;
114 | 		vector<int>v[N];
115 | 		int cnt = 0;
116 | 		
117 | 		int sum = 0;
118 | 		
119 | 		for(int i = 0;i < N; i++){
120 | 			int t;
121 | 			cin>>t;
122 | 			for(int j = 0;j < t;j++){
123 | 				string aux;
124 | 				cin >> aux;
125 | 				if(name.find(aux) == name.end())
126 | 					name[aux] = cnt++;
127 | 				v[i].push_back(name[aux]);
128 | 			}
129 | 			
130 | 			sum += (1<<t);
131 | 			sort(v[i].begin(),v[i].end());
132 | 		}
133 | 		
134 | 		cnt = 0;
135 | 		n = sum;
136 | 		
137 | 		for(int i = 0; i < N;i++){
138 | 			int t = v[i].size();
139 | 			//cout<<"i "<<i<<" "<<t<<endl;
140 | 			for(int mask = 1; mask < (1<<t);mask++){
141 | 				int ones = __builtin_popcount(mask);
142 | 				vector<int>aux;
143 | 				for(int j =0;j < t;j++)
144 | 					if( (mask&(1<<j)) != 0)
145 | 						aux.push_back(v[i][j]);
146 | 				
147 | 				if(encode.find(aux)==encode.end())
148 | 					encode[aux] = cnt++;			
149 | 				
150 | 				int t2 = aux.size();
151 | 				
152 | 				for(int mask2 = 1; mask2<(1<<t2);mask2++){
153 | 					int ones2 = __builtin_popcount(mask2);
154 | 					if(ones2+1 == ones){
155 | 						vector<int>aux2;
156 | 						for(int j =0;j < t2;j++)
157 | 							if( (mask2&(1<<j)) != 0)
158 | 								aux2.push_back(aux[j]);
159 | 						if(encode.find(aux2) == encode.end())
160 | 							encode[aux2] = cnt++;
161 | 						
162 | 						// UNION encode[aux] ->encode[aux2]
163 | 						adj[encode[aux]].push_back(n+encode[aux2]);
164 | 					}
165 | 				}
166 | 			}
167 | 		}
168 | 		
169 | 		m= sum;        
170 | 		cout<<(int)encode.size()-hopcroft_karp()<<endl;
171 | 	}
172 | 	
173 | 		
174 | 	return 0;
175 | }
176 | 


--------------------------------------------------------------------------------
/solucionario regional 2013/h.cpp:
--------------------------------------------------------------------------------
  1 | #include <vector>
  2 | #include <list>
  3 | #include <map>
  4 | #include <set>
  5 | #include <queue>
  6 | #include <deque>
  7 | #include <stack>
  8 | #include <bitset>
  9 | #include <algorithm>
 10 | #include <functional>
 11 | #include <numeric>
 12 | #include <utility>
 13 | #include <sstream>
 14 | #include <iostream>
 15 | #include <iomanip>
 16 | #include <cstdio>
 17 | #include <cmath>
 18 | #include <cstdlib>
 19 | #include <ctime>
 20 | #include <string.h>
 21 | #include <stdio.h>
 22 | #define f(i,x,y) for (int i = x; i < y; i++)
 23 | #define fd(i,x,y) for(int i = x; i>= y; i--)
 24 | #define FOR(it,A) for(typeof A.begin() it = A.begin(); it!=A.end(); it++)
 25 | #define all(v) (v).begin(), (v).end()
 26 | #define rall(v) (v).rbegin(), (v).rend()
 27 | #define vint vector<int>
 28 | #define ll long long
 29 | #define clr(A,x) memset(A, x, sizeof A)
 30 | #define pb push_back
 31 | #define pii pair<int,int>
 32 | #define fst first
 33 | #define snd second
 34 | #define ones(x) __builtin_popcount(x)
 35 | #define cua(x) (x)*(x)
 36 | #define eps (1e-14)
 37 | #define oo (1<<30)
 38 | #define debug(x) cout <<#x << " = " << x << endl
 39 | #define adebug(x,n) cout <<#x<<endl; f(i,0,n)cout<<x[i]<<char(i+1==n?10:32)
 40 | #define mdebug(x,m,n) cout <<#x<<endl; f(i,0,m)f(j,0,n)cout<<x[i][j]<<char(j+1==n?10:32)
 41 | #define N 10005
 42 | using namespace std;
 43 | template<class T> inline void mini(T &a,T b){if(b<a) a=b;}
 44 | template<class T> inline void maxi(T &a,T b){if(b>a) a=b;}
 45 | 
 46 | 
 47 | struct punto {
 48 | 	long double x,y;
 49 | 	punto(long double x, double y): x(x), y(y) {}
 50 | 	punto() {}
 51 | 	punto operator+ (punto p) { return punto(x + p.x, y + p.y); }
 52 | 	punto operator- (punto p) { return punto(x - p.x, y - p.y); }
 53 | 	punto operator* (long double t) { return punto(x*t, y*t); }
 54 | 	punto operator/ (long double t) { return punto(x/t, y/t); }
 55 | 	long double operator*(punto p) { return x*p.x + y*p.y; }
 56 | 	long double operator%(punto p) { return x*p.y - y*p.x; }
 57 | 	long double tam() { return x*x + y*y; }
 58 | 	punto operator~() { return punto(-y,x); }
 59 | 	void read() { scanf("%Lf%Lf", &x, &y); }
 60 | 	void print() { printf("%.6Lf %.6Lf\n", x, y); }
 61 | };
 62 | struct superpunto {
 63 | 	punto p; int z;
 64 | 	superpunto(punto p, int z) : p(p), z(z) {}
 65 | 	superpunto() {}
 66 | };
 67 | 
 68 | punto O,w;
 69 | int above(punto p) {
 70 | 	if (p.y == O.y) return p.x > O.x;
 71 | 	return p.y > O.y;
 72 | }
 73 | bool ordenCircular(punto p, punto q) {
 74 | 	int tmp = above(q) - above(p);
 75 | 	if (tmp!=0) return tmp > 0;
 76 | 	return (p-O)%(q-O) > 0;
 77 | }
 78 | bool ordenCircular2(superpunto P, superpunto Q) {
 79 | 	return ordenCircular(P.p, Q.p);
 80 | }
 81 | 
 82 | long double cmp(double a, double b=0) { return a < b-eps? -1 : a > b+eps? 1 : 0; }
 83 | long double norma(punto a, punto b = punto(0,0)) { return hypot(a.x-b.x, a.y-b.y); }
 84 | long double angulo(punto a, punto b) { 
 85 | 	a = a/norma(a);
 86 | 	b = b/norma(b);
 87 | 	long double calfa = a*b;
 88 | 	mini(calfa, (long double)1.0);
 89 | 	maxi(calfa, (long double)-1.0);
 90 | 	return acos(calfa);
 91 | }
 92 | 
 93 | struct recta{
 94 | 	punto u,v;
 95 | 	recta() {}
 96 | 	recta(punto u, punto v): u(u), v(v) {}
 97 | 	long double tam() {
 98 | 		long double den = (u-v)%(w-O);
 99 | 		if (cmp(den)==0) return -1e100;
100 | 		long double t = (u-O)%(w-O) / den; //solucion de u+(v-u)t-O paralelo a (w-O)
101 | 		if (cmp(t,0)<0 || cmp(t,1) > 0) return -1e100;
102 | 		punto p = (u-O) + (v-u)*t;
103 | 		if ( p*(w-O) < 0) return -1e100;//cmp no es necesario porque no puede ser 0
104 | 		return p.tam();
105 | 	}
106 | };
107 | bool operator<(recta r1, recta r2) {
108 | 	return r1.tam() < r2.tam();
109 | }
110 | punto p[N];
111 | recta r[N];
112 | 
113 | int main(){
114 | 	int S,K,W;
115 | 	while(scanf("%d%d%d", &S, &K, &W) == 3) {
116 | 		f(i,0,K) p[i].read();
117 | 
118 | 		f(i,0,W) {
119 | 			punto u,v;
120 | 			u.read(); v.read();
121 | 			r[i] = recta(u,v);
122 | 		}
123 | 		if (K == 1) {
124 | 			cout << 0 << endl;
125 | 			continue;
126 | 		}
127 | 		
128 | 		f(i,0,S) {
129 | 			int res = 0;
130 | 			O = p[i];
131 | 			vector<superpunto> L;
132 | 			f(j,0,K) if(j!=i) L.pb(superpunto(p[j], -1));
133 | 			f(j,0,W) {
134 | 				long double tmp = (r[j].u-O) % (r[j].v-O);
135 | 				if (tmp < 0) swap(r[j].u, r[j].v);
136 | 				L.pb( superpunto(r[j].u, j*2) );
137 | 				L.pb( superpunto(r[j].v, j*2+1) );
138 | 			}
139 | 			sort(all(L), ordenCircular2);
140 | 
141 | 			set<recta> R;
142 | 			w = L[0].p;
143 | 			f(j,0,W) {
144 | 				if (r[j].tam() > 0) R.insert(r[j]);
145 | 			}
146 | 			
147 | 			f(j,0,L.size()) {
148 | 				int z = L[j].z;
149 | 				w = L[j].p;
150 | 				if(z<0) {
151 | 					if (R.empty()) {
152 | 						res++;
153 | 						continue;
154 | 					}
155 | 					recta pr = *R.begin();
156 | 					if (pr.tam() > (w-O).tam()) res++;
157 | 				} else if (z%2 == 0) R.insert(r[z>>1]);
158 | 				else R.erase(r[z>>1]);
159 | 			}
160 | 			cout << res << endl;
161 | 		}
162 | 	}
163 | }
164 | 


--------------------------------------------------------------------------------
/solucionario regional 2012/g.cpp:
--------------------------------------------------------------------------------
  1 | #include <ctime>
  2 | #include <numeric>
  3 | #include <functional>
  4 | #include <iostream>
  5 | #include <vector>
  6 | #include <algorithm>
  7 | #include <bitset>
  8 | #include <string>
  9 | #include <cstring>
 10 | #include <climits>
 11 | #include <cmath>
 12 | #include <cctype>
 13 | #include <sstream>
 14 | #include <map>
 15 | #include <set>
 16 | #include <cstdio>
 17 | #include <queue>
 18 | using namespace std;
 19 | #define MAXN 5001
 20 | #define INF (1<<28)
 21 |   
 22 | vector <int> adj[MAXN + 1]; // (u, v) <=> (v, u)
 23 | int n, m, NIL, match[MAXN + 1], dist[MAXN + 1];
 24 | // Izquierda; nodos del 0 al n-1
 25 | // Derecha: Nodos del n al n+m-1
 26 | // NIL: Nodo n+m
 27 | 
 28 | int R,C;  
 29 |   
 30 | bool bfs(){
 31 |     queue <int> Q;
 32 |     for(int i=0; i<n; i++) {
 33 |         if(match[i] == NIL) {
 34 |             dist[i] = 0;
 35 |             Q.push(i);
 36 |         }
 37 |         else dist[i] = INF;
 38 |     }
 39 |     dist[NIL] = INF;
 40 |       
 41 |     while(!Q.empty()) {
 42 |         int u = Q.front(); Q.pop();
 43 |         for(int i=0; i<adj[u].size(); i++){
 44 |             int v = adj[u][i];
 45 |             if(dist[match[v]] == INF) {
 46 |                 dist[match[v]] = dist[u] + 1;
 47 |                 Q.push(match[v]);
 48 |             }
 49 |         }
 50 |     }
 51 |     return dist[NIL] != INF;
 52 | }
 53 |   
 54 | bool dfs(int u) {
 55 |     if(u != NIL) {
 56 |         for(int i=0; i<adj[u].size(); i++) {
 57 |             int v = adj[u][i];
 58 |             if(dist[match[v]] == dist[u] + 1) {
 59 |                 if(dfs(match[v])) {
 60 |                     
 61 |                     match[v] = u;
 62 |                     match[u] = v;
 63 |                     return true;
 64 |                 }
 65 |             }
 66 |         }
 67 |         dist[u] = INF;
 68 |         return false;
 69 |     }
 70 |     return true;
 71 | }
 72 |   
 73 | int hopcroft_karp(){
 74 |     NIL = n + m;
 75 |     for(int i=0; i<n+m; i++)
 76 |         match[i] = NIL;
 77 |       
 78 |     int matching = 0;
 79 |       
 80 |     //Greedy Step
 81 |     for(int u=0; u<n; u++){
 82 |         for(int i=0; i<adj[u].size(); i++){
 83 |             int v = adj[u][i];
 84 |             if(match[v] == NIL){
 85 |                 matching++;
 86 |                 match[u] = v;
 87 |                 match[v] = u;
 88 |                 break;
 89 |             }
 90 |         }
 91 |     }
 92 |       
 93 |     while(bfs())
 94 |         for(int u=0; u<n; u++)
 95 |             if(match[u] == NIL && dfs(u))
 96 |                 matching++;
 97 |     
 98 |     return matching;
 99 | }
100 | 
101 | int win=0;
102 | char grid[51][51];
103 | bool visited[51][51];
104 | int di[4]={-1,1,0,0};
105 | int dj[4]={0,0,1,-1};
106 | int cantdos,cantuno;
107 | 
108 | void colorear(int i,int j,int val){
109 |     if(val==1)cantuno++;
110 |     if(val==2)cantdos++;
111 |     visited[i][j]=1;
112 |     
113 |     for(int k=0;k<4;k++){
114 |         int X=i+di[k];
115 |         int Y=j+dj[k];
116 |         if(X>=0 && X<R && Y>=0 && Y<C){
117 |             if(!visited[X][Y] && grid[X][Y]=='.'){
118 |                 if(val==1){
119 |                     adj[i*C+j].push_back(X*C+Y+m);
120 |                 }else{
121 |                     adj[X*C+Y].push_back(i*C+j+m);   
122 |                 }
123 |             }    
124 |         }
125 |     }
126 |     
127 |     
128 |     for(int k=0;k<4;k++){
129 |         int X=i+di[k];
130 |         int Y=j+dj[k];
131 |         if(X>=0 && X<R && Y>=0 && Y<C){
132 |             if(!visited[X][Y] && grid[X][Y]=='.'){
133 |                 if(val==1){
134 |                     colorear(X,Y,2);    
135 |                 }else{
136 |                     colorear(X,Y,1);        
137 |                 }
138 |             }    
139 |         }
140 |     }
141 |            
142 |     return ;
143 | }
144 | 
145 | 
146 | int main(){
147 |     
148 |     //freopen("in.txt","r",stdin);
149 |     //freopen("out.txt","w",stdout);
150 |     
151 |     while(cin>>R>>C){
152 |         
153 |         for(int i=0;i<R;i++)
154 |             scanf("%s",grid[i]);
155 |         
156 |         memset(visited,0,sizeof(visited));
157 |         win=2;
158 |         n=R*C;
159 |         m=R*C;
160 |         
161 |         for(int i=0;i<R;i++)
162 |             for(int j=0;j<C;j++){
163 |                 if(grid[i][j]=='X')continue;
164 |                 if(visited[i][j])continue;
165 |                 for(int k=0;k<R*C;k++)
166 |                     if(adj[k].size()!=0)
167 |                         adj[k].clear();
168 |                 cantdos=0;
169 |                 cantuno=0;
170 |                 colorear(i,j,1);  
171 |                 
172 |                 
173 |                 if( !(cantuno==cantdos && hopcroft_karp()==cantuno)){
174 |                     win=1;
175 |                     goto next;
176 |                 }
177 |                 
178 |                 
179 |             }
180 |             
181 |         next:
182 |         cout<<win<<endl;
183 |     }
184 |     
185 |     return 0;    
186 | }
187 | 


--------------------------------------------------------------------------------
/solucionario regional 2012/j.cpp:
--------------------------------------------------------------------------------
  1 | #include <ctime>
  2 | #include <numeric>
  3 | #include <functional>
  4 | #include <iostream>
  5 | #include <vector>
  6 | #include <algorithm>
  7 | #include <bitset>
  8 | #include <string>
  9 | #include <cstring>
 10 | #include <climits>
 11 | #include <cmath>
 12 | #include <cctype>
 13 | #include <sstream>
 14 | #include <map>
 15 | #include <set>
 16 | #include <cstdio>
 17 | #include <queue>
 18 | using namespace std;
 19 | #define MAX 100005
 20 | int uf[MAX];
 21 | int FIND(int x){ return uf[x]==x? x:uf[x] = FIND(uf[x]); }
 22 | void UNION(int x,int y){ uf[FIND(x)] = FIND(y); }
 23 | 
 24 | int n;
 25 | int p[100001];
 26 | int P[100001][17];
 27 | int L[100001];
 28 | int val[100001];
 29 | 
 30 | int pciclo[100001];
 31 | int Pciclo[100001];
 32 | int   papi[100001];
 33 | 
 34 | bool visited[100001];
 35 | vector<int>v[100001];
 36 | int tamciclo[100001];
 37 | 
 38 | void getArbol(int node,int nivel){
 39 |     visited[node]=1;
 40 |     L[node]=nivel;
 41 |     
 42 |     for(int i=0;i<v[node].size();i++){
 43 |         int t=v[node][i];
 44 |         if(!visited[t]){
 45 |             if(pciclo[t]!=-1){
 46 |                 getArbol(t,nivel);
 47 |             }else{
 48 |                 papi[t]=node;
 49 |                 getArbol(t,nivel+1);
 50 |             }         
 51 |         }    
 52 |     }
 53 |     
 54 |     return ;
 55 | }
 56 | 
 57 | void init(){
 58 |     for(int i=0;i<n;i++)
 59 |         if(pciclo[i]!=-1)P[i][0]=-1;
 60 |         else P[i][0]=papi[i];
 61 |     
 62 |     for(int i=1;(1<<i)<=n;i++)
 63 |         for(int j=0;j<n;j++)
 64 |             if(P[j][i-1]!=-1)
 65 |                 P[j][i]=P[P[j][i-1]][i-1];        
 66 | }
 67 | 
 68 | pair<int,int> lca(int a,int b){
 69 |     if(a==b)return make_pair(a,b);
 70 |     if(L[a]<L[b])swap(a,b);
 71 |     
 72 |     int dif=L[a]-L[b];
 73 |     
 74 |     for(int i=16;i>=0;i--){
 75 |         if(dif>=(1<<i)){
 76 |             dif-=1<<i;
 77 |             a=P[a][i];
 78 |         }
 79 |     }
 80 |     
 81 |     if(a==b || L[a]==0)return make_pair(a,b);
 82 |     
 83 |     for(int i=16;i>=0;i--){
 84 |         if(P[a][i] != P[b][i] && L[P[a][i]]!=0){
 85 |             a=P[a][i];
 86 |             b=P[b][i];
 87 |         }
 88 |     }
 89 |     
 90 |     return make_pair(papi[a],papi[b]);
 91 | }
 92 | 
 93 | int main(){
 94 |     
 95 |     //freopen("input.txt","r",stdin);
 96 |     //freopen("out.txt","w",stdout);
 97 |     
 98 |     while(cin>>n){
 99 |         memset(p,-1,sizeof(p));
100 |         memset(P,-1,sizeof(P));
101 |         memset(pciclo,-1,sizeof(pciclo));
102 |         memset(papi,-1,sizeof(papi));
103 |         memset(visited,0,sizeof(visited));
104 |         memset(L,0,sizeof(L));
105 |         memset(tamciclo,0,sizeof(tamciclo));
106 |         memset(val,0,sizeof(val));
107 |         
108 |         int u;
109 |         for(int i=0;i<n;i++)uf[i]=i;
110 |         for(int i=0;i<n;i++)v[i].clear();
111 |         
112 |         for(int i=0;i<n;i++){
113 |             scanf("%d",&u);  
114 |             u--;
115 |             if(FIND(i)==FIND(u)){
116 |                 int aux=i;
117 |                 int tam=0;
118 |                 p[i]=u;
119 |                 
120 |                 while(true){
121 |                     tam++;
122 |                     visited[aux]=1;
123 |                     pciclo[aux]=p[aux];
124 |                     aux=p[aux];
125 |                     if(visited[aux])break;    
126 |                 }
127 |                 
128 |                 int aux2=i;
129 |             
130 |                 for(int j=1;;j++){
131 |                     val[aux2]=j;
132 |                     tamciclo[aux2]=tam;
133 |                     aux2=p[aux2];
134 |                     if(aux2==aux)break;    
135 |                 }
136 |             }
137 |             
138 |             UNION(i,u);
139 |             p[i]=u;
140 |             v[i].push_back(u);
141 |             v[u].push_back(i);
142 |         }
143 |         
144 |         int q;
145 |         cin>>q;
146 |         memset(visited,0,sizeof(visited));
147 |         
148 |         for(int i=0;i<n;i++)
149 |             if(pciclo[i]!=-1 && !visited[i])
150 |                 getArbol(i,0);
151 |         
152 |         
153 |         for(int i=0;i<n;i++)
154 |             if(!visited[i])
155 |                 getArbol(i,0);
156 |         
157 |         init();
158 |         
159 |         for(int i=0;i<q;i++){
160 |             int a,b;
161 |             scanf("%d %d",&a,&b);
162 |             a--;b--;
163 |             if(FIND(a)!=FIND(b) ){
164 |                 printf("-1\n");    
165 |             }else{
166 |                 pair<int,int> node=lca(a,b);
167 |                 
168 |                 if(node.first==node.second)
169 |                     printf("%d\n",L[a]-L[node.first]+L[b]-L[node.first] );
170 |                 else{
171 |                     int dif=abs(val[node.first]-val[node.second]);
172 |                     printf("%d\n",L[a]+L[b]+ min( tamciclo[node.first]-dif,dif) );
173 |                 }
174 |             }
175 |         }    
176 |         
177 |     }
178 |     
179 |     return 0;    
180 | }
181 | 


--------------------------------------------------------------------------------
/solucionario regional 2017/L.cpp:
--------------------------------------------------------------------------------
  1 | #include<iostream>
  2 | #include<cstring>
  3 | #include<cstdio>
  4 | #include<vector>
  5 | #include<cmath>
  6 | #include<sstream>
  7 | #include<algorithm>
  8 | #include<set>
  9 | #include<queue>
 10 | using namespace std;
 11 | int x[100005];
 12 | int y[100005];
 13 | int X[100005];
 14 | int Y[100005];
 15 | int rightx[100005];// where is number one
 16 | int leftx[100005];
 17 | int righty[100005];// where is number one
 18 | int lefty[100005];
 19 | int n;
 20 | 
 21 | int print(int x1,int y1,int x2,int y2){
 22 | 	int dx=X[max(x1,x2)-1]-X[min(x1,x2)-1];
 23 | 	int dy=Y[max(y1,y2)-1]-Y[min(y1,y2)-1];
 24 | 	return dx+dy;
 25 | }
 26 | 
 27 | int solve(int x1,int y1,int x2,int y2){
 28 | 	int ans=1<<30;
 29 | 	int dx=abs(x1-x2);
 30 | 	int dy=abs(y1-y2);
 31 | 	
 32 | 	if(dx>dy){
 33 | 		int miss= dx-dy;
 34 | 		int dir=1;
 35 | 		if(x1>x2)dir=-1;
 36 | 		int val=1<<30;
 37 | 		
 38 | 		if(y1<n){
 39 | 		    val= 2*(miss/2)*y[y1]+abs(X[x1+dir*miss-1]-X[x1-1]) +print(x1+dir*miss,y1,x2,y2);
 40 | 			ans=min(ans,val);
 41 | 		}
 42 | 		
 43 | 		if(y1>1)
 44 | 			val= 2*(miss/2)*y[y1-1]+abs(X[x1+dir*miss-1]-X[x1-1]) +print(x1+dir*miss,y1,x2,y2);
 45 | 		ans=min(ans,val);
 46 | 			
 47 | 		return ans;
 48 | 	}else{
 49 | 		int miss= dy-dx;
 50 | 		
 51 | 		
 52 | 		if(y1<y2){
 53 | 			int val=1<<30;
 54 | 			if(x1<n)
 55 | 				val= 2*(miss/2)*x[x1]+Y[y1+miss-1]-Y[y1-1] +print(x1,y1+miss,x2,y2);
 56 | 			
 57 | 			ans=min(ans,val);
 58 | 			if(x1>1)
 59 | 				val= 2*(miss/2)*x[x1-1]+Y[y1+miss-1]-Y[y1-1] +print(x1,y1+miss,x2,y2);
 60 | 			ans=min(ans,val);
 61 | 		}else{
 62 | 			int val=1<<30;
 63 | 			if(x1<n)
 64 | 				val= 2*(miss/2)*x[x1]+Y[y1-1]-Y[y1-miss-1]+  print(x1,y1-miss,x2,y2);
 65 | 			
 66 | 			ans=min(ans,val);
 67 | 			if(x1>1)
 68 | 				val= 2*(miss/2)*x[x1-1]+Y[y1-1]-Y[y1-miss-1]+print(x1,y1-miss,x2,y2);
 69 | 			ans=min(ans,val);
 70 | 		}
 71 | 		
 72 | 	}
 73 | 
 74 | 
 75 | 	return ans;
 76 | }
 77 | 
 78 | int main(){
 79 | 	//freopen("in.txt","r",stdin);
 80 | 	//freopen("out.txt","w",stdout);
 81 | 	
 82 | 	
 83 | 	while(scanf("%d",&n)==1){
 84 | 		
 85 | 		x[0]=0;y[0]=0;
 86 | 		
 87 | 		for(int i=0;i<n-1;i++)scanf("%d",&x[i+1]);
 88 | 		for(int i=0;i<n-1;i++)scanf("%d",&y[i+1]);
 89 | 		
 90 | 		rightx[n]=righty[n]=-1;
 91 | 		for(int i=n-1;i>=1;i--){
 92 | 			if(x[i]==1)
 93 | 				rightx[i]=i+1;
 94 | 			else
 95 | 				rightx[i]=rightx[i+1];
 96 | 				
 97 | 			if(y[i]==1)
 98 | 				righty[i]=i+1;
 99 | 			else
100 | 				righty[i]=righty[i+1];
101 | 		}
102 | 		
103 | 		leftx[1]=lefty[1]=-1;
104 | 		for(int i=1;i<n;i++){
105 | 			if(x[i]==1)
106 | 				leftx[i+1]=i;
107 | 			else
108 | 				leftx[i+1]=leftx[i];
109 | 				
110 | 			if(y[i]==1)
111 | 				lefty[i+1]=i;
112 | 			else
113 | 				lefty[i+1]=lefty[i];
114 | 		}
115 | 		
116 | 		
117 | 		X[0]=Y[0]=0;
118 | 		for(int i=1;i<n;i++)X[i]=X[i-1]+x[i];
119 | 		for(int i=1;i<n;i++)Y[i]=Y[i-1]+y[i];
120 | 		
121 | 		int q;
122 | 		scanf("%d",&q);
123 | 		
124 | 		while(q--){
125 | 			int x1,y1,x2,y2;
126 | 			scanf("%d %d %d %d",&x1,&y1,&x2,&y2);
127 | 			if(x1>x2){
128 | 				swap(x1,x2);
129 | 				swap(y1,y2);
130 | 			}
131 | 			
132 | 			int dx=abs(x1-x2);
133 | 			int dy=abs(y1-y2);
134 | 			
135 | 			if(dx==dy){
136 | 				int val=print(x1,y1,x2,y2);
137 | 				printf("%d\n",val);
138 | 				continue;
139 | 			}
140 | 			
141 | 			int ans= solve(x1,y1,x2,y2);
142 | 			
143 | 			if(dx>dy){
144 | 				int sum=0;
145 | 				if(righty[y1]!=-1 ){
146 | 					int miss= righty[y1]-y1;
147 | 					if(x1+miss<=n && y1+miss<=n){
148 | 						sum=X[x1+miss-1]-X[x1-1]+Y[y1+miss-1]-Y[y1-1];
149 | 						ans=min(ans,sum+solve(x1+miss,y1+miss,x2,y2));
150 | 					}
151 | 					
152 | 				}
153 | 					
154 | 				sum=0;
155 | 				if(lefty[y1]!=-1 ){
156 | 					int miss= y1 -lefty[y1];
157 | 					if(x1+miss<=n && y1-miss>=1){
158 | 						sum=X[x1+miss-1]-X[x1-1]+Y[y1-1]-Y[y1-miss-1];
159 | 						ans=min(ans,sum+solve(x1+miss,y1-miss,x2,y2));
160 | 					}
161 | 					
162 | 				}					
163 | 			}else{
164 | 				int sum=0;
165 | 				if(rightx[x1]!=-1 ){
166 | 					int miss= rightx[x1]-x1;
167 | 					
168 | 					
169 | 					if(y2>y1){
170 | 						if(x1+miss<=n && y1+miss<=n){
171 | 							sum=X[x1+miss-1]-X[x1-1]+Y[y1+miss-1]-Y[y1-1];
172 | 							ans=min(ans,sum+solve(x1+miss,y1+miss,x2,y2));
173 | 						}
174 | 					}else{
175 | 						if(x1+miss<=n && y1-miss>=1){
176 | 							sum=X[x1+miss-1]-X[x1-1]+Y[y1-1]-Y[y1-miss-1];
177 | 							ans=min(ans,sum+solve(x1+miss,y1-miss,x2,y2));
178 | 						}
179 | 					}
180 | 					
181 | 					
182 | 				}
183 | 						
184 | 					
185 | 				sum=0;
186 | 				if(leftx[x1]!=-1 ){
187 | 					int miss= x1 -leftx[x1];
188 | 					if(y2>y1){
189 | 						if(x1-miss>=1 && y1+miss<=n){
190 | 							sum=X[x1-1]-X[x1-miss-1]+Y[y1+miss-1]-Y[y1-1];
191 | 							ans=min(ans,sum+solve(x1-miss,y1+miss,x2,y2));
192 | 						}
193 | 					}else{
194 | 						if(x1-miss>=1 && y1-miss>=1){
195 | 							sum=X[x1-1]-X[x1-miss-1]+Y[y1-1]-Y[y1-miss-1];
196 | 							ans=min(ans,sum+solve(x1-miss,y1-miss,x2,y2));		
197 | 						}
198 | 					}
199 | 				}	
200 | 						
201 | 			}	
202 | 			
203 | 			printf("%d\n",ans);
204 | 		}
205 | 				
206 | 	}
207 | 		
208 | 	return 0;
209 | }
210 | 
211 | 


--------------------------------------------------------------------------------
/solucionario regional 2013/j.cpp:
--------------------------------------------------------------------------------
  1 | #include <vector>
  2 | #include <list>
  3 | #include <map>
  4 | #include <set>
  5 | #include <queue>
  6 | #include <deque>
  7 | #include <stack>
  8 | #include <bitset>
  9 | #include <algorithm>
 10 | #include <functional>
 11 | #include <numeric>
 12 | #include <utility>
 13 | #include <sstream>
 14 | #include <iostream>
 15 | #include <iomanip>
 16 | #include <cstdio>
 17 | #include <cmath>
 18 | #include <cstdlib>
 19 | #include <ctime>
 20 | #include <string.h>
 21 | #include <stdio.h>
 22 | #define all(v) (v).begin(),(v).end()
 23 | #define rall(v) (v).rbegin(),(v).rend()
 24 | using namespace std;  // H A M L E T
 25 | vector<int>v1[40001],v2[40001];
 26 | int dis1[40001];
 27 | int dis2[40001];
 28 | int visited[40001];
 29 | 
 30 | pair<int,int>diametro(vector<int>v[40001]){
 31 |     memset(visited,0,sizeof(visited));
 32 |     queue<int>Q;
 33 |     Q.push(0);
 34 |     int ini=0;
 35 |     
 36 |     while(!Q.empty()){
 37 |         ini=Q.front();
 38 |         Q.pop();
 39 |         visited[ini]=1;
 40 |         
 41 |         for(int i=0;i<v[ini].size();i++){
 42 |             if(!visited[v[ini][i]]){
 43 |                 Q.push(v[ini][i]);    
 44 |             }        
 45 |         }
 46 |         
 47 |     }
 48 |     
 49 |     int fin=ini;
 50 |     while(!Q.empty())Q.pop();
 51 |  
 52 |     Q.push(ini);
 53 |     memset(visited,0,sizeof(visited));
 54 |     
 55 |     while(!Q.empty()){
 56 |         fin=Q.front();
 57 |         Q.pop();
 58 |         visited[fin]=1;
 59 |         
 60 |         for(int i=0;i<v[fin].size();i++){
 61 |             if(!visited[v[fin][i]]){
 62 |                 Q.push(v[fin][i]);    
 63 |             }        
 64 |         }
 65 |         
 66 |     }
 67 |     
 68 |     return make_pair(ini,fin);
 69 | }
 70 | 
 71 | void llenar1(int node){
 72 |     queue<int>Q;
 73 |     Q.push(node);
 74 |     memset(visited,-1,sizeof(visited));    
 75 |     visited[node]=0;
 76 |     
 77 |     while(!Q.empty()){
 78 |         int nodo=Q.front();
 79 |         dis1[nodo]=max(dis1[nodo],visited[nodo]);
 80 |         Q.pop();
 81 |         for(int i=0;i<v1[nodo].size();i++)
 82 |             if(visited[v1[nodo][i]]==-1){
 83 |                 Q.push(v1[nodo][i]);    
 84 |                 visited[v1[nodo][i]]=visited[nodo]+1;
 85 |             }  
 86 |     }
 87 | }
 88 | 
 89 | void llenar2(int node){
 90 |     queue<int>Q;
 91 |     Q.push(node);
 92 |     memset(visited,-1,sizeof(visited));    
 93 |     visited[node]=0;
 94 |     
 95 |     while(!Q.empty()){
 96 |         int nodo=Q.front();
 97 |         dis2[nodo]=max(dis2[nodo],visited[nodo]);
 98 |         Q.pop();
 99 |         for(int i=0;i<v2[nodo].size();i++)
100 |             if(visited[v2[nodo][i]]==-1){
101 |                 Q.push(v2[nodo][i]);    
102 |                 visited[v2[nodo][i]]=visited[nodo]+1;
103 |             }  
104 |     }
105 | }
106 | 
107 | 
108 | 
109 | 
110 | void bfs(){
111 |     memset(dis1,0,sizeof(dis1));
112 |     memset(dis2,0,sizeof(dis2));
113 |     
114 |     pair<int,int>d1=diametro(v1);
115 |     pair<int,int>d2=diametro(v2);
116 |         
117 |     //cout<<"diametro "<<d1.first<<" "<<d1.second<<" "<<d2.first<<" "<<d2.second<<endl;     
118 |     
119 |     llenar1(d1.first);
120 |     llenar1(d1.second);
121 |     
122 |     llenar2(d2.first);
123 |     llenar2(d2.second);
124 | }
125 | 
126 | long long F[40001];
127 | int main(){
128 |     
129 |     
130 |     int n,q;
131 |     
132 |     while(cin>>n>>q){
133 |         
134 |         for(int i=0;i<40001;i++){v1[i].clear();v2[i].clear();}
135 |         
136 |         for(int i=0;i<n-1;i++){
137 |             int a,b;
138 |             scanf("%d %d",&a,&b);
139 |             a--;
140 |             b--;
141 |             v1[a].push_back(b);  
142 |             v1[b].push_back(a);  
143 |         }
144 |         
145 |         for(int i=0;i<q-1;i++){
146 |             int a,b;
147 |             scanf("%d %d",&a,&b);
148 |             a--;
149 |             b--;
150 |             v2[a].push_back(b);
151 |             v2[b].push_back(a);    
152 |         }
153 |         
154 |         
155 |         bfs();
156 |         long long sum1=0;long long sum2=0;
157 |         long long dev=0;
158 |         int maxi=0;
159 |         
160 |         for(int i=0;i<n;i++){sum1+=dis1[i];maxi=max(maxi,dis1[i]);}
161 |         sort(dis2,dis2+q);
162 |         
163 |         for(int i=0;i<q;i++){sum2+=dis2[i];maxi=max(maxi,dis2[i]);}
164 |         
165 |         
166 |         for(int i=q-1;i>=0;i--){
167 |             if(i==q-1)F[i]=dis2[i];
168 |             else F[i]=dis2[i]+F[i+1];
169 |             
170 |         }
171 |         
172 |         for(int i=0;i<n;i++){
173 |             
174 |             //for(int j=0;j<q;j++)
175 |             //    dev+=max(maxi,dis1[i]+dis2[j]+1);
176 |             
177 |             
178 |             int id=lower_bound(dis2,dis2+q,maxi-(dis1[i]+1))-dis2;
179 |             dev+=(long long)maxi*id;
180 |             if(id<q)dev+=F[id]+(dis1[i]+1)*(long long)(q-id);  
181 |             
182 |         }
183 |         
184 |         
185 |         printf("%.3lf\n",(double)dev/((long long)n*q));
186 |     }
187 |     
188 |     return 0;
189 | }
190 | 


--------------------------------------------------------------------------------
/solucionario regional 2013/b.cpp:
--------------------------------------------------------------------------------
  1 | #include <vector>
  2 | #include <list>
  3 | #include <map>
  4 | #include <set>
  5 | #include <queue>
  6 | #include <deque>
  7 | #include <stack>
  8 | #include <bitset>
  9 | #include <algorithm>
 10 | #include <functional>
 11 | #include <numeric>
 12 | #include <utility>
 13 | #include <sstream>
 14 | #include <iostream>
 15 | #include <assert.h>
 16 | #include <iomanip>
 17 | #include <cstdio>
 18 | #include <cmath>
 19 | #include <cstdlib>
 20 | #include <ctime>
 21 | #include <string.h>
 22 | #include <stdio.h>
 23 | #define all(v) (v).begin(),(v).end()
 24 | #define rall(v) (v).rbegin(),(v).rend()
 25 | using namespace std;  // H A M L E T
 26 | string s,t;
 27 | int n,m,q;
 28 | 
 29 | long long mascara[400001];
 30 | int flag[400001];
 31 | 
 32 | inline void init(int node,int a,int b){
 33 |     if(a==b){
 34 |         long long mask=0;
 35 |         if(n-a>=m){
 36 |             for(int i=0;i<m;i++)
 37 |                 if(tolower(t[i])==tolower(s[a+i])){
 38 |                     if(isupper(s[a+i])){
 39 |                         mask|=(1<<i);
 40 |                     }
 41 |                 }else{
 42 |                     mask=-1;
 43 |                     break;
 44 |                 }
 45 |         }else mask=-1;
 46 |         
 47 |         if(mask!=-1)mascara[node]=1LL<<mask; 
 48 |         else mascara[node]=0;
 49 |         flag[node]=0;
 50 |         return ;
 51 |     }
 52 |     
 53 |     init(2*node+1,a,(a+b)/2);
 54 |     init(2*node+2,(a+b)/2+1,b);
 55 |     
 56 |     mascara[node]=mascara[2*node+1]|mascara[2*node+2];    
 57 |     flag[node]=0;
 58 |     
 59 | }
 60 | 
 61 | inline void push(int node,int a,int b){
 62 |     if(flag[node]==1){
 63 |         long long aux=mascara[node];
 64 |         long long aux2=0;
 65 |         
 66 |         for(int i=(1<<m)-1;i>=0;i--){
 67 |             if((aux&(1LL<<i))!=0 )
 68 |                 aux2|=1LL<<(i^((1<<m)-1));
 69 |         }
 70 |         
 71 |         mascara[node]=aux2;
 72 |         flag[node]=0;
 73 |         
 74 |         
 75 |         if(a!=b){
 76 |             flag[2*node+1]=!flag[2*node+1];
 77 |             flag[2*node+2]=!flag[2*node+2];
 78 |         } 
 79 |         
 80 |     }
 81 |     
 82 |     if(flag[node]<0){
 83 |         flag[node]=-flag[node];
 84 |         
 85 |         if(mascara[node]==0){
 86 |             flag[node]=0;
 87 |             return;
 88 |         }
 89 |         
 90 |         int cont=0;
 91 |         long long x=mascara[node];
 92 |         while(x!=1){
 93 |             cont++;
 94 |             x/=2;
 95 |         }
 96 |         
 97 |         mascara[node]=1LL<<(cont^((1<<flag[node])-1));
 98 |         flag[node]=0;
 99 |     }
100 |         
101 | }
102 | 
103 | inline long long query(int node,int p,int q,int a,int b){
104 |     push(node,p,q);
105 |     if(q<a || p>b)return 0;
106 |     
107 |     if(a<=p && q<=b)return mascara[node];
108 |     
109 |     long long v1=query(2*node+1,p,(p+q)/2,a,b);
110 |     long long v2=query(2*node+2,(p+q)/2+1,q,a,b);
111 |     
112 |     mascara[node]=mascara[2*node+1]|mascara[2*node+2];
113 |     
114 |     return v1|v2;
115 | }
116 | 
117 | void update(int node,int p,int q,int a,int b){
118 |     push(node,p,q);
119 |     if(q<a || p>b)return ;
120 |     
121 |     if(a<=p && q<=b){
122 |         flag[node]=1;
123 |         push(node,p,q);
124 |         return ;    
125 |     }
126 |     
127 |     update(2*node+1,p,(p+q)/2,a,b);
128 |     update(2*node+2,(p+q)/2+1,q,a,b);
129 |     
130 |     mascara[node]=mascara[2*node+1]|mascara[2*node+2];   
131 |     return ;
132 | }
133 | 
134 | void update2(int node,int p,int q,int a,int b){
135 |     push(node,p,q);
136 |     if(q<a || p>b)return ;
137 |     
138 |     if(p==q){
139 |         flag[node]=-(b-p+1);
140 |         push(node,p,q);
141 |         return ;    
142 |     }
143 |     
144 |     update2(2*node+1,p,(p+q)/2,a,b);
145 |     update2(2*node+2,(p+q)/2+1,q,a,b);
146 |     
147 |     mascara[node]=mascara[2*node+1]|mascara[2*node+2];
148 |     
149 |     return ;
150 | }
151 | 
152 | int main(){
153 |     
154 |     while(cin>>q){
155 |         cin>>t>>s;
156 |         n=s.size();
157 |         m=t.size();
158 |         
159 |         init(0,0,n-1);
160 |         int maximo[32];
161 |         for(int i=0;i<(1<<m);i++){
162 |             int cont=0;
163 |             for(int j=0;j<m;j++){
164 |                 if( ((i&(1<<j))==0&& isupper(t[j])) || 
165 |                     ((i&(1<<j))!=0&& islower(t[j]))){
166 |                     cont++;        
167 |                 }
168 |             }
169 |             maximo[i]=cont;
170 |         }
171 |         
172 |         for(int i=0;i<q;i++){
173 |             int a,b;
174 |             scanf("%d %d",&a,&b);
175 |             a--;b--;
176 |             
177 |             if(b-a+1<m)printf("-1\n");
178 |             else{
179 |                 long long mask=query(0,0,n-1,a,b-m+1);
180 |                  
181 |                 int maxi=-1;
182 |                 
183 |                 if(mask!=0){
184 |                     for(int j=0;j<(1<<m);j++)
185 |                         if( (mask&(1LL<<j))!=0 ){
186 |                             maxi=max(maxi,maximo[j]);
187 |                         }
188 |                 }
189 |                 
190 |                 printf("%d\n",maxi);
191 |                 
192 |             }
193 |             
194 |             if(b-m+1>=0)
195 |                 update(0,0,n-1,0,b-m+1);
196 |             
197 |             update2(0,0,n-1,max(0,b-m+2),b);
198 |             
199 |             if(a-m>=0)
200 |                 update(0,0,n-1,0,a-m);
201 |             
202 |             if(a>0)    
203 |                 update2(0,0,n-1,max(0,a-1-m+2),a-1);
204 |             
205 |         }        
206 |     }
207 |     
208 |     return 0;
209 | }
210 | 


--------------------------------------------------------------------------------
/Solucionario regional 2019/C.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <cstring>
  3 | #include <cmath>
  4 | #include <map>
  5 | #include <vector>
  6 | #include <string>
  7 | #include <algorithm>
  8 | #include <set>
  9 | #include <map>
 10 | #include <unordered_map>
 11 | using namespace std;
 12 | int n,L,U;
 13 | long long c[100005];
 14 | long long rightP[100005][2];
 15 | long long rightPL[17][100005][2];
 16 | 
 17 | struct st{
 18 |     long long sum,maxpref,minpref;
 19 |     
 20 |     st(){}
 21 |     st(long long _sum, long long _maxpref ,long long _minpref){
 22 |         sum = _sum;
 23 | 		maxpref = _maxpref;
 24 | 		minpref = _minpref;  
 25 |     }
 26 | }tree[400005];
 27 | 
 28 | void init(int i , int j , int node ){
 29 |     if(i == j){
 30 | 	   tree[node].sum = tree[node].maxpref = tree[node].minpref = c[i];
 31 |        return ;
 32 |     }
 33 |     
 34 |     int v1 = 2*node + 1;
 35 |     int v2 = 2*node + 2;
 36 |     init( i , (i+j)/2 ,v1);
 37 |     init( (i+j)/2 + 1 , j ,v2);
 38 |     
 39 |     tree[node].sum = tree[v1].sum +tree[v2].sum;
 40 |     tree[node].maxpref  = max(tree[v1].maxpref, tree[v1].sum +tree[v2].maxpref);
 41 |     tree[node].minpref  = min(tree[v1].minpref, tree[v1].sum +tree[v2].minpref);;
 42 | }
 43 | 
 44 | st query( int start , int end , int node , int i , int j ){
 45 |     if( i > end || j < start ) return st(-1LL<<60,-1,-1);
 46 |     if( i <= start && end <=j )return tree[node];
 47 |     
 48 | 	int v1 = 2*node + 1;
 49 |     int v2 = 2*node + 2;
 50 |     
 51 |     st ret1 = query( start , (start+end)/2 , 2*node + 1 , i , j );
 52 |     st ret2 = query( (start+end)/2 + 1 , end , 2*node + 2, i , j );
 53 |     
 54 | 	if( ret2.sum == (-1LL<<60) )return ret1;
 55 |     if( ret1.sum == (-1LL<<60) )return ret2;
 56 |     
 57 |     st ans;
 58 | 	ans.sum = ret1.sum + ret2.sum;
 59 | 	ans.maxpref = max(ret1.maxpref, ret1.sum + ret2.maxpref ); 
 60 | 	ans.minpref = min(ret1.minpref, ret1.sum + ret2.minpref );
 61 |     return ans;
 62 | }
 63 | 
 64 | 
 65 | int main() {
 66 | 	while(scanf("%d %d %d",&n, &L, &U) == 3){
 67 | 		for(int i = 0 ; i < n; i++){
 68 | 			int aux;scanf("%d",&aux);	
 69 | 			c[i] =aux;
 70 | 		}
 71 | 		init(0,n-1,0);
 72 | 		
 73 | 		//right[i][0] starting with X = L find next position where X will be L
 74 | 		//right[i][1] starting with X = U find next position where X will be U
 75 | 		for(int i = 0; i< n;i++){
 76 | 			int lo = i;
 77 | 			int hi = n;
 78 | 			
 79 | 			//right[i][0]
 80 | 			while(lo != hi){
 81 | 				int me = (lo+hi)/2;
 82 | 				st evaluate = query(0,n-1,0,i,me);
 83 | 				if(L + evaluate.maxpref<= U && evaluate.minpref>=0  ){
 84 | 					lo = me+1;
 85 | 				}else{
 86 | 					hi = me;
 87 | 				}
 88 | 			}
 89 | 			
 90 | 			if(lo == n){
 91 | 				rightP[i][0]=1<<30;
 92 | 			}else{
 93 | 				st aux = query(0,n-1,0,i,lo);
 94 | 				if(L + aux.maxpref> U ){
 95 | 					rightP[i][0] = lo;
 96 | 				}else{
 97 | 					rightP[i][0] = -lo;
 98 | 				}	
 99 | 			}
100 | 			
101 | 			lo = i; hi=n;
102 | 			//right[i][1]
103 | 			while(lo != hi){
104 | 				int me = (lo+hi)/2;
105 | 				st evaluate = query(0,n-1,0,i,me);
106 | 				if(U + evaluate.minpref>= L && evaluate.maxpref<=0  ){
107 | 					lo = me+1;
108 | 				}else{
109 | 					hi = me;
110 | 				}
111 | 			}
112 | 			
113 | 			if(lo == n){
114 | 				rightP[i][1]= 1<<30;
115 | 			}else{
116 | 				st aux = query(0,n-1,0,i,lo);
117 | 				if(U + aux.minpref< L ){
118 | 					rightP[i][1] = -lo;
119 | 				}else{
120 | 					rightP[i][1] = lo;
121 | 				}	
122 | 			}
123 | 			
124 | 		}
125 | 
126 | 		for(int i = 0;i<n;i++)rightPL[0][i][0] = rightP[i][0];
127 | 		for(int i = 0;i<n;i++)rightPL[0][i][1] = rightP[i][1];
128 | 		rightPL[0][n][0]=rightPL[0][n][1]=n;
129 | 		
130 | 		for(int L = 1; L <= 16; L++){
131 | 			rightPL[L][n][0]=rightPL[L][n][1]=n;
132 | 			
133 | 			for(int i = 0; i< n; i++){
134 | 				int nextval = rightPL[L-1][i][0];
135 | 				if(abs(nextval) < n){
136 | 					if(nextval <0 )
137 | 						rightPL[L][i][0] = rightPL[L-1][-nextval+1][0];
138 | 					else
139 | 						rightPL[L][i][0] = rightPL[L-1][nextval+1][1];
140 | 				}else{
141 | 					rightPL[L][i][0] = n;
142 | 				}
143 | 			}
144 | 			
145 | 			
146 | 			for(int i = 0; i< n; i++){
147 | 				int nextval = rightPL[L-1][i][1];
148 | 				if(abs(nextval) < n){
149 | 					if(nextval <0 )
150 | 						rightPL[L][i][1] = rightPL[L-1][-nextval+1][0];
151 | 					else
152 | 						rightPL[L][i][1] = rightPL[L-1][nextval+1][1];
153 | 				}else{
154 | 					rightPL[L][i][1] = n;
155 | 				}
156 | 			}
157 | 		}
158 | 		
159 | 		int q;
160 | 		scanf("%d",&q);
161 | 		
162 | 		for(int ncase = 1; ncase <= q; ncase++){
163 | 			int startMonth, endMonth, X;
164 | 			scanf("%d %d %d",&startMonth,&endMonth,&X);
165 | 			int f1 = startMonth,f2= endMonth, f3=X;
166 | 			
167 | 			startMonth--;
168 | 			endMonth--;
169 | 			
170 | 			st aux = query(0,n-1,0,startMonth,endMonth);
171 | 			
172 | 			
173 | 			if( X+ aux.maxpref <= U && X+aux.minpref>=L ){
174 | 				printf("%d\n", X+aux.sum);
175 | 				continue;
176 | 			}else{
177 | 				int lo = startMonth;
178 | 				int hi = endMonth+1;
179 | 				
180 | 				while(lo != hi){
181 | 					int me = (lo+hi)/2;
182 | 					st evaluate = query(0,n-1,0,startMonth,me);
183 | 					if(X + evaluate.maxpref<= U && X + evaluate.minpref>=L  ){
184 | 						lo = me+1;
185 | 					}else{
186 | 						hi = me;
187 | 					}
188 | 				}
189 | 				
190 | 				if(lo ==endMonth){
191 | 					st aux = query(0,n-1,0,startMonth,lo);
192 | 					if( X + aux.sum > U )printf("%d\n", U);
193 | 					else if(X + aux.sum < L )printf("%d\n", L);
194 | 					else {
195 | 						int result = (int)(X+aux.sum);
196 | 					}
197 | 					continue;
198 | 				}else{
199 | 					int nextMonth = lo + 1;
200 | 					int value = -1;
201 | 					int id =0;
202 | 					st aux = query(0,n-1,0,startMonth,lo);
203 | 					if(X + aux.maxpref>U ){
204 | 						value = U;
205 | 						id = 1;
206 | 					}else{
207 | 						id = 0;
208 | 						value = L;
209 | 					}
210 | 					
211 | 					for(int i=16;i>=0;i--){
212 | 						if( abs(rightPL[i][nextMonth][id]) >endMonth ){
213 | 							continue;
214 | 						}else{
215 | 							nextMonth = rightPL[i][nextMonth][id];
216 | 							if(nextMonth < 0){
217 | 								nextMonth = -nextMonth+1;
218 | 								value = L;
219 | 								id = 0;
220 | 							}else{
221 | 								nextMonth++;
222 | 								value = U;
223 | 								id = 1;
224 | 							}
225 | 						}
226 | 					}
227 | 					
228 | 					
229 | 					if(nextMonth > endMonth){
230 | 						printf("%d\n",(int)value );
231 | 					}else{
232 | 						long long done = value + query(0,n-1,0,nextMonth,endMonth).sum;
233 | 						
234 | 						if( done >U){
235 | 							printf("%d\n",U );
236 | 						}else{
237 | 							if(done < L){
238 | 								printf("%d\n",L );
239 | 							}else{
240 | 								printf("%d\n",done);
241 | 							}
242 | 						}
243 | 					}
244 | 				}
245 | 			}
246 | 		}	
247 | 	}
248 | 	
249 | 	return 0;
250 | }
251 | 


--------------------------------------------------------------------------------