├── README.md
├── Articles
    ├── Stress Testing
    │   ├── good implementation using diff
    │   │   ├── code.cpp
    │   │   ├── gen.cpp
    │   │   ├── brute.cpp
    │   │   └── script.sh
    │   ├── good implementation using checker
    │   │   ├── script.sh
    │   │   ├── gen.cpp
    │   │   ├── code.cpp
    │   │   ├── brute.cpp
    │   │   └── checker.cpp
    │   └── bad implementation
    │   │   └── main.cpp
    ├── Polygon.CodeForces Tutorial
    │   ├── val.cpp
    │   ├── sol_correct.cpp
    │   ├── sol.cpp
    │   ├── gen.cpp
    │   └── check.cpp
    ├── monotonic queue.cpp
    └── Maximum Independent Set.cpp
└── AtCoder
    ├── abc178
        ├── a.cpp
        ├── b.cpp
        ├── d_Formula.cpp
        ├── c_inclusion_exclusion.cpp
        ├── c_dp.cpp
        ├── f.cpp
        ├── d_Combinatorics.cpp
        └── e.cpp
    ├── abc179
        ├── a.cpp
        ├── c.cpp
        ├── b.cpp
        ├── e.cpp
        ├── d.cpp
        └── f.cpp
    └── abc185
        ├── a.cpp
        ├── c.cpp
        ├── b.cpp
        ├── d.cpp
        ├── e.cpp
        └── f.cpp


/README.md:
--------------------------------------------------------------------------------
1 | # Competitive-Programming


--------------------------------------------------------------------------------
/Articles/Stress Testing/good implementation using diff/code.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int main() {
 5 |     int w;
 6 |     cin>>w;
 7 |     if(w%2==0)cout<<"YES"<<endl;
 8 |     else cout<<"NO"<<endl;
 9 | }
10 | 


--------------------------------------------------------------------------------
/Articles/Stress Testing/good implementation using diff/gen.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int rnd(int a, int b){
 4 |     return a + rand() % (b - a + 1);
 5 | }
 6 | int main(int argc, char* argv[]){
 7 |     int seed = atoi(argv[1]);
 8 |     srand(seed);
 9 |     int w = rnd(1, 100);
10 |     cout<<w<<endl;
11 | }
12 | 


--------------------------------------------------------------------------------
/Articles/Stress Testing/good implementation using diff/brute.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int main() {
 4 |     int w;
 5 |     cin>>w;
 6 |     for(int i=1;i<w;i++){
 7 |         int j = w - i;
 8 |         if(i%2==0 && j%2==0){
 9 |             cout<<"YES"<<endl;
10 |             return 0;
11 |         }
12 |     }
13 |     cout<<"NO"<<endl;
14 | }
15 | 


--------------------------------------------------------------------------------
/Articles/Stress Testing/good implementation using checker/script.sh:
--------------------------------------------------------------------------------
 1 | set -e
 2 | g++ code.cpp -o code
 3 | g++ gen.cpp -o gen
 4 | g++ brute.cpp -o brute
 5 | g++ checker.cpp -o checker
 6 | for((i = 1; ; ++i)); do
 7 |     ./gen $i > input_file
 8 |     ./code < input_file > myAnswer
 9 |     ./brute < input_file > correctAnswer
10 |     ./checker > checker_log
11 |     echo "Passed test: "  $i
12 | done
13 | 
14 | 


--------------------------------------------------------------------------------
/Articles/Stress Testing/good implementation using checker/gen.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int rnd(int a, int b){
 4 |     return a + rand() % (b - a + 1);
 5 | }
 6 | int main(int argc, char* argv[]){
 7 |     int seed = atoi(argv[1]);
 8 |     srand(seed);
 9 |     int n = rnd(1, 5);
10 |     cout<<n<<endl;
11 |     for(int i=0;i<2*n;i++){
12 |         int x = rnd(1, 10);
13 |         cout<<x<<" ";
14 |     }
15 |     cout<<endl;
16 | }
17 | 


--------------------------------------------------------------------------------
/Articles/Stress Testing/good implementation using checker/code.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | long long a[200005];
 4 | int main(){
 5 | 	long long n;
 6 | 	cin>>n;
 7 | 	long long sum2 = 0;
 8 | 	for(long long i = 1;i<=2*n;i++){
 9 | 		cin>>a[i];
10 | 		sum2+=a[i];
11 | 	}
12 | 	sort(a+1,a+1+2*n);
13 | 	long long sum=0;
14 | 	for(long long i = 1;i<=n;i++){
15 | 		sum+=a[i];
16 | 	}
17 | 	if(sum==sum2/2) cout<<"-1";
18 | 	else for(long long i = 1;i<=2*n;i++) cout<<a[i]<<" ";
19 | 	cout<<endl;
20 | }
21 | 


--------------------------------------------------------------------------------
/Articles/Stress Testing/good implementation using diff/script.sh:
--------------------------------------------------------------------------------
 1 | set -e
 2 | g++ code.cpp -o code
 3 | g++ gen.cpp -o gen
 4 | g++ brute.cpp -o brute
 5 | for((i = 1; ; ++i)); do
 6 |     ./gen $i > input_file
 7 |     ./code < input_file > myAnswer
 8 |     ./brute < input_file > correctAnswer
 9 |     diff -Z myAnswer correctAnswer > /dev/null || break
10 |     echo "Passed test: "  $i
11 | done
12 | echo "WA on the following test:"
13 | cat input_file
14 | echo "Your answer is:"
15 | cat myAnswer
16 | echo "Correct answer is:"
17 | cat correctAnswer
18 | 


--------------------------------------------------------------------------------
/Articles/Stress Testing/good implementation using checker/brute.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | int main(){
 4 |     int n;
 5 |     cin>>n;
 6 |     vector<int>a(2*n);
 7 |     for(int i=0;i<2*n;i++)cin>>a[i];
 8 |     sort(a.begin(), a.end());
 9 |     do{
10 |         int s1 = 0, s2 = 0;
11 |         for(int i=0;i<n;i++){
12 |             s1+=a[i];
13 |             s2+=a[i+n];
14 |         }
15 |         if(s1!=s2){
16 |             for(auto x:a)cout<<x<<" "; cout<<endl;
17 |             exit(0);
18 |         }
19 |     }while(next_permutation(a.begin(), a.end()));
20 |     cout<<-1<<endl;
21 | }
22 | 


--------------------------------------------------------------------------------
/AtCoder/abc178/a.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | #define ll long long int
 3 | #define pb push_back
 4 | #define endl '\n'
 5 | #define Endl '\n'
 6 | #define fi first
 7 | #define ii pair<int,int>
 8 | #define iil pair<ll,ll>
 9 | #define se second
10 | #define ld long double
11 | #define mod 1000000007
12 | #define popcount __builtin_popcountll
13 | #define x0 zxcxzcsacasd
14 | #define x1 ghfghujfgfg
15 | #define y0 olkjhdnncvcv
16 | #define y1 bhvgrewm345345435
17 | #define debug(x) std::cerr<<#x<<": "<<(x)<<'\n'
18 | #define all(x) x.begin(), x.end()
19 | using namespace std;
20 | int main(){
21 | 	int x;
22 | 	cin>>x;
23 | 	cout<<1-x<<endl;
24 | }
25 | 
26 | 


--------------------------------------------------------------------------------
/Articles/Polygon.CodeForces Tutorial/val.cpp:
--------------------------------------------------------------------------------
 1 | #include "testlib.h"
 2 | #include <bits/stdc++.h>
 3 | using namespace std;
 4 | bool prime(int x){
 5 |     if(x == 1)return false;
 6 | 	for(int i = 2;i * i <= x;i++){
 7 | 		if(x%i == 0)return false;
 8 | 	}
 9 | 	return true;
10 | }
11 | int main(int argc, char** argv){
12 |     registerValidation(argc, argv);
13 |     int n = inf.readInt(1, 1000,"N");
14 |     inf.readEoln();
15 |     bool has_prime = false;
16 |     for(int i = 1;i <= n;i++){
17 | 		int x = inf.readInt(1, 1000, "X");
18 | 		has_prime|=prime(x);
19 | 		if(i != n)inf.readSpace();
20 | 	}
21 | 	inf.readEoln();
22 |     ensuref(has_prime, "There is no prime number!");
23 |     inf.readEof();
24 |     return 0;
25 | }
26 | 
27 | 


--------------------------------------------------------------------------------
/AtCoder/abc179/a.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | #define ll long long int
 3 | #define pb push_back
 4 | #define endl '\n'
 5 | #define Endl '\n'
 6 | #define fi first
 7 | #define ii pair<int,int>
 8 | #define iil pair<ll,ll>
 9 | #define se second
10 | #define ld long double
11 | #define mod 1000000007
12 | #define popcount __builtin_popcountll
13 | #define x0 zxcxzcsacasd
14 | #define x1 ghfghujfgfg
15 | #define y0 olkjhdnncvcv
16 | #define y1 bhvgrewm345345435
17 | #define debug(x) std::cerr<<#x<<": "<<(x)<<'\n'
18 | #define all(x) x.begin(), x.end()
19 | using namespace std;
20 | 
21 | int main(){
22 | 	string s;
23 | 	cin>>s;
24 | 	int n = s.length();
25 | 	if(s[n-1]!='s')cout<<s<<"s"<<endl;
26 | 	else cout<<s<<"es"<<endl;
27 | }
28 | 


--------------------------------------------------------------------------------
/AtCoder/abc185/a.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | #define ll long long int
 3 | #define pb push_back
 4 | #define endl '\n'
 5 | #define Endl '\n'
 6 | #define fi first
 7 | #define ii pair<int,int>
 8 | #define iil pair<ll,ll>
 9 | #define se second
10 | #define ld long double
11 | #define mod 0
12 | #define popcount __builtin_popcountll
13 | #define x0 zxcxzcsacasd
14 | #define x1 ghfghujfgfg
15 | #define y0 olkjhdnncvcv
16 | #define y1 bhvgrewm345345435
17 | #define debug(x) std::cerr<<#x<<": "<<(x)<<'\n'
18 | #define all(x) x.begin(), x.end()
19 | using namespace std;
20 | 
21 | 
22 | int main(){
23 | 	int a, b, c, d;
24 | 	cin>>a>>b>>c>>d;
25 | 	int ans = min(a, b);
26 | 	ans = min(ans, c);
27 | 	ans = min(ans, d);
28 | 	cout<<ans<<endl;
29 | }
30 | 
31 | 


--------------------------------------------------------------------------------
/AtCoder/abc178/b.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | #define ll long long int
 3 | #define pb push_back
 4 | #define endl '\n'
 5 | #define Endl '\n'
 6 | #define fi first
 7 | #define ii pair<int,int>
 8 | #define iil pair<ll,ll>
 9 | #define se second
10 | #define ld long double
11 | #define mod 1000000007
12 | #define popcount __builtin_popcountll
13 | #define x0 zxcxzcsacasd
14 | #define x1 ghfghujfgfg
15 | #define y0 olkjhdnncvcv
16 | #define y1 bhvgrewm345345435
17 | #define debug(x) std::cerr<<#x<<": "<<(x)<<'\n'
18 | #define all(x) x.begin(), x.end()
19 | using namespace std;
20 | 
21 | int main(){
22 | 	ll a, b, c, d;
23 | 	cin>>a>>b>>c>>d;
24 | 	ll ans = a * c;
25 | 	ans = max(ans, a * d);
26 | 	ans = max(ans, b * c);
27 | 	ans = max(ans, b * d);
28 | 	cout<<ans<<endl;
29 | }
30 | 
31 | 


--------------------------------------------------------------------------------
/AtCoder/abc179/c.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | #define ll long long int
 3 | #define pb push_back
 4 | #define endl '\n'
 5 | #define Endl '\n'
 6 | #define fi first
 7 | #define ii pair<int,int>
 8 | #define iil pair<ll,ll>
 9 | #define se second
10 | #define ld long double
11 | #define mod 1000000007
12 | #define popcount __builtin_popcountll
13 | #define x0 zxcxzcsacasd
14 | #define x1 ghfghujfgfg
15 | #define y0 olkjhdnncvcv
16 | #define y1 bhvgrewm345345435
17 | #define debug(x) std::cerr<<#x<<": "<<(x)<<'\n'
18 | #define all(x) x.begin(), x.end()
19 | using namespace std;
20 | 
21 | int main(){
22 | 	int n;
23 | 	cin>>n;
24 | 	int ans = 0;
25 | 	for(int a = 1; a <= n; a++){
26 | 		for(int b = 1; b <= n; b++){
27 | 			int c = n - a * b;
28 | 			if(c>0)ans++;
29 | 			else break;
30 | 		}
31 | 	}
32 | 	cout<<ans<<endl;
33 | }
34 | 


--------------------------------------------------------------------------------
/AtCoder/abc178/d_Formula.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | #define ll long long int
 3 | #define pb push_back
 4 | #define endl '\n'
 5 | #define Endl '\n'
 6 | #define fi first
 7 | #define ii pair<int,int>
 8 | #define iil pair<ll,ll>
 9 | #define se second
10 | #define ld long double
11 | #define mod 1000000007
12 | #define popcount __builtin_popcountll
13 | #define x0 zxcxzcsacasd
14 | #define x1 ghfghujfgfg
15 | #define y0 olkjhdnncvcv
16 | #define y1 bhvgrewm345345435
17 | #define debug(x) std::cerr<<#x<<": "<<(x)<<'\n'
18 | #define all(x) x.begin(), x.end()
19 | using namespace std;
20 | ll dp[3030];
21 | 
22 | int main(){
23 | 	int s;
24 | 	cin>>s;
25 | 	dp[0] = 0;
26 | 	dp[1] = 0;
27 | 	dp[2] = 0;
28 | 	dp[3] = 1;
29 | 	for(int i=4;i<=s;i++){
30 | 		dp[i] = dp[i-1] + dp[i-3];
31 | 		dp[i]%=mod;
32 | 	}
33 | 	cout<<dp[s]<<endl;
34 | }
35 | 
36 | 


--------------------------------------------------------------------------------
/AtCoder/abc179/b.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | #define ll long long int
 3 | #define pb push_back
 4 | #define endl '\n'
 5 | #define Endl '\n'
 6 | #define fi first
 7 | #define ii pair<int,int>
 8 | #define iil pair<ll,ll>
 9 | #define se second
10 | #define ld long double
11 | #define mod 1000000007
12 | #define popcount __builtin_popcountll
13 | #define x0 zxcxzcsacasd
14 | #define x1 ghfghujfgfg
15 | #define y0 olkjhdnncvcv
16 | #define y1 bhvgrewm345345435
17 | #define debug(x) std::cerr<<#x<<": "<<(x)<<'\n'
18 | #define all(x) x.begin(), x.end()
19 | using namespace std;
20 | 
21 | int main(){
22 | 	int n, counter = 0;
23 | 	cin>>n;
24 | 	for(int i=0;i<n;i++){
25 | 		int x, y;
26 | 		scanf("%d%d", &x, &y);
27 | 		if(x==y)counter++;
28 | 		else counter = 0;
29 | 		if(counter>=3){
30 | 			cout<<"Yes"<<endl;
31 | 			return 0;
32 | 		}
33 | 	}
34 | 	cout<<"No"<<endl;
35 | }
36 | 


--------------------------------------------------------------------------------
/Articles/Polygon.CodeForces Tutorial/sol_correct.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | #define ll long long int
 3 | #define pb push_back
 4 | #define endl '\n'
 5 | #define Endl '\n'
 6 | #define fi first
 7 | #define ii pair<int,int>
 8 | #define iil pair<ll,ll>
 9 | #define se second
10 | #define ld long double
11 | #define mod 1000000007
12 | #define popcount __builtin_popcountll
13 | #define x0 zxcxzcsacasd
14 | #define x1 ghfghujfgfg
15 | #define y0 olkjhdnncvcv
16 | #define y1 bhvgrewm345345435
17 | #define debug(x) std::cerr<<#x<<": "<<(x)<<'\n'
18 | #define all(x) x.begin(), x.end()
19 | using namespace std;
20 | bool prime(int x){
21 | 	for(int i = 2; i * i <= x;i++){
22 | 		if(x%i == 0)return false;
23 | 	}
24 | 	return true;
25 | }
26 | int main(){
27 | 	int n;
28 | 	cin>>n;
29 | 	int ans = 0;
30 | 	for(int i = 0;i < n;i++){
31 | 		int x;
32 | 		scanf("%d", &x);
33 | 		if(x!=1 && prime(x))ans = x;
34 | 	}
35 | 	cout<<ans<<endl;
36 | }
37 | 


--------------------------------------------------------------------------------
/AtCoder/abc178/c_inclusion_exclusion.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | #define ll long long int
 3 | #define pb push_back
 4 | #define endl '\n'
 5 | #define Endl '\n'
 6 | #define fi first
 7 | #define ii pair<int,int>
 8 | #define iil pair<ll,ll>
 9 | #define se second
10 | #define ld long double
11 | #define mod 1000000007
12 | #define popcount __builtin_popcountll
13 | #define x0 zxcxzcsacasd
14 | #define x1 ghfghujfgfg
15 | #define y0 olkjhdnncvcv
16 | #define y1 bhvgrewm345345435
17 | #define debug(x) std::cerr<<#x<<": "<<(x)<<'\n'
18 | #define all(x) x.begin(), x.end()
19 | using namespace std;
20 | ll p(ll a, ll b){
21 | 	if(b==0)return 1;
22 | 	ll ret=p(a, b/2);
23 | 	ret*=ret;
24 | 	ret%=mod;
25 | 	if(b%2)ret*=a;
26 | 	return ret%mod;
27 | }
28 | int main(){
29 | 	int n;
30 | 	cin>>n;
31 | 	ll ans = p(10, n);
32 | 	ans-=2*p(9, n);
33 | 	ans%=mod;
34 | 	if(ans<0)ans+=mod;
35 | 	ans+=p(8, n);
36 | 	ans%=mod;
37 | 	cout<<ans<<endl;
38 | }
39 | 
40 | 


--------------------------------------------------------------------------------
/AtCoder/abc185/c.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | #define ll long long int
 3 | #define pb push_back
 4 | #define endl '\n'
 5 | #define Endl '\n'
 6 | #define fi first
 7 | #define ii pair<int,int>
 8 | #define iil pair<ll,ll>
 9 | #define se second
10 | #define ld long double
11 | #define mod 0
12 | #define popcount __builtin_popcountll
13 | #define x0 zxcxzcsacasd
14 | #define x1 ghfghujfgfg
15 | #define y0 olkjhdnncvcv
16 | #define y1 bhvgrewm345345435
17 | #define debug(x) std::cerr<<#x<<": "<<(x)<<'\n'
18 | #define all(x) x.begin(), x.end()
19 | using namespace std;
20 | ll l;
21 | ll dp[202][12];
22 | ll cal(int i, int c){
23 | 	if(i == l)return 0;
24 | 	if(c == 11)return 1;
25 | 	ll &ret = dp[i][c];
26 | 	if(ret!=-1)return ret;
27 | 	ret = 0;
28 | 	ret  = cal(i + 1, c);
29 | 	ret += cal(i + 1, c + 1);
30 | 	return ret;
31 | }
32 | 
33 | int main(){
34 | 	cin>>l;
35 | 	memset(dp, -1, sizeof dp);
36 | 	cout<<cal(0, 0)<<endl;
37 | 
38 | }
39 | 
40 | 


--------------------------------------------------------------------------------
/Articles/Polygon.CodeForces Tutorial/sol.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | #define ll long long int
 3 | #define pb push_back
 4 | #define endl '\n'
 5 | #define Endl '\n'
 6 | #define fi first
 7 | #define ii pair<int,int>
 8 | #define iil pair<ll,ll>
 9 | #define se second
10 | #define ld long double
11 | #define mod 1000000007
12 | #define popcount __builtin_popcountll
13 | #define x0 zxcxzcsacasd
14 | #define x1 ghfghujfgfg
15 | #define y0 olkjhdnncvcv
16 | #define y1 bhvgrewm345345435
17 | #define debug(x) std::cerr<<#x<<": "<<(x)<<'\n'
18 | #define all(x) x.begin(), x.end()
19 | using namespace std;
20 | bool prime(int x){
21 | 	if(x == 1)return false;
22 | 	for(int i = 2; i * i <= x;i++){
23 | 		if(x%i == 0)return false;
24 | 	}
25 | 	return true;
26 | }
27 | int main(){
28 | 	int n;
29 | 	cin>>n;
30 | 	for(int i = 0;i < n;i++){
31 | 		int x;
32 | 		scanf("%d", &x);
33 | 		if(prime(x)){
34 | 			cout<<x<<endl;
35 | 			return 0;
36 | 		}
37 | 	}
38 | }
39 | 


--------------------------------------------------------------------------------
/Articles/Polygon.CodeForces Tutorial/gen.cpp:
--------------------------------------------------------------------------------
 1 | #include "testlib.h"
 2 | #include <bits/stdc++.h>
 3 | #define pb push_back
 4 | #define ll long long int
 5 | #define ii pair<int, int>
 6 | using namespace std;
 7 | bool prime(int x){
 8 |     if(x == 1)return false;
 9 | 	for(int i = 2; i * i <= x;i++){
10 | 		if(x%i == 0)return false;
11 | 	}
12 | 	return true;
13 | }
14 | int main(int argc, char* argv[]){
15 | 	registerGen(argc, argv, 1);
16 | 	int min_n = atoi(argv[1]);
17 | 	int max_n = atoi(argv[2]);
18 | 	int n = rnd.next(min_n, max_n);
19 | 	cout<<n<<endl;
20 | 	vector<int>a(n);
21 | 	bool has_prime = false;
22 | 	for(int i = 0;i < n;i++){
23 | 		a[i] = rnd.next(1, 1000);
24 | 		has_prime|=prime(a[i]);
25 | 	}
26 | 	while(!has_prime){
27 | 		int x = rnd.next(1, 1000);
28 | 		has_prime|=prime(x);
29 | 		a[0] = x;
30 | 	}
31 | 	shuffle(a.begin(), a.end());
32 | 	cout<<a[0];
33 | 	for(int i = 1;i < n;i++){
34 | 		cout<<" "<<a[i];
35 | 	}
36 | 	cout<<endl;
37 |     return 0;
38 | }
39 | 


--------------------------------------------------------------------------------
/AtCoder/abc178/c_dp.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | #define ll long long int
 3 | #define pb push_back
 4 | #define endl '\n'
 5 | #define Endl '\n'
 6 | #define fi first
 7 | #define ii pair<int,int>
 8 | #define iil pair<ll,ll>
 9 | #define se second
10 | #define ld long double
11 | #define mod 1000000007
12 | #define popcount __builtin_popcountll
13 | #define x0 zxcxzcsacasd
14 | #define x1 ghfghujfgfg
15 | #define y0 olkjhdnncvcv
16 | #define y1 bhvgrewm345345435
17 | #define debug(x) std::cerr<<#x<<": "<<(x)<<'\n'
18 | #define all(x) x.begin(), x.end()
19 | using namespace std;
20 | ll dp[1000010][2][2];
21 | int n;
22 | ll cal(int i, int f, int ff){
23 | 	if(i==n)return f&&ff;
24 | 	ll &ret=dp[i][f][ff];
25 | 	if(ret!=-1)return ret;
26 | 	ret++;
27 | 	ret += 8*cal(i + 1, f, ff); ret%=mod;
28 | 	ret += cal(i + 1, 1, ff); ret%=mod;
29 | 	ret += cal(i + 1, f, 1); ret%=mod;
30 | 	return ret;
31 | }
32 | int main(){
33 | 	cin>>n;
34 | 	memset(dp,-1,sizeof dp);
35 | 	cout<<cal(0, 0, 0)<<endl;
36 | }
37 | 
38 | 


--------------------------------------------------------------------------------
/AtCoder/abc185/b.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | #define ll long long int
 3 | #define pb push_back
 4 | #define endl '\n'
 5 | #define Endl '\n'
 6 | #define fi first
 7 | #define ii pair<int,int>
 8 | #define iil pair<ll,ll>
 9 | #define se second
10 | #define ld long double
11 | #define mod 0
12 | #define popcount __builtin_popcountll
13 | #define x0 zxcxzcsacasd
14 | #define x1 ghfghujfgfg
15 | #define y0 olkjhdnncvcv
16 | #define y1 bhvgrewm345345435
17 | #define debug(x) std::cerr<<#x<<": "<<(x)<<'\n'
18 | #define all(x) x.begin(), x.end()
19 | using namespace std;
20 | 
21 | 
22 | int main(){
23 | 	ll n, m , rem, pos = 0;
24 | 	cin >> n >> m >> rem;
25 | 	ll mx = n;
26 | 	for(int i = 0; i < m;i++){
27 | 		ll a, b;
28 | 		cin >> a >> b;
29 | 		n-=(a - pos);
30 | 		if(n <= 0){
31 | 			puts("No");
32 | 			return 0;
33 | 		}
34 | 		n += (b - a);
35 | 		n = min(n, mx);
36 | 		pos = b;
37 | 	}
38 | 	n-=(rem - pos);
39 | 	if(n <= 0){
40 | 		puts("No");
41 | 		return 0;
42 | 	}
43 | 	puts("Yes");
44 | }
45 | 
46 | 


--------------------------------------------------------------------------------
/AtCoder/abc185/d.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | #define ll long long int
 3 | #define pb push_back
 4 | #define endl '\n'
 5 | #define Endl '\n'
 6 | #define fi first
 7 | #define ii pair<int,int>
 8 | #define iil pair<ll,ll>
 9 | #define se second
10 | #define ld long double
11 | #define mod 0
12 | #define popcount __builtin_popcountll
13 | #define x0 zxcxzcsacasd
14 | #define x1 ghfghujfgfg
15 | #define y0 olkjhdnncvcv
16 | #define y1 bhvgrewm345345435
17 | #define debug(x) std::cerr<<#x<<": "<<(x)<<'\n'
18 | #define all(x) x.begin(), x.end()
19 | using namespace std;
20 | 
21 | 
22 | int main(){
23 | 	int n, m;
24 | 	cin>>n>>m;
25 | 	if(m == 0){
26 | 		cout<<1<<endl;
27 | 		return 0;
28 | 	}
29 | 	vector<int>a(m + 2);
30 | 	a[0] = 0;
31 | 	for(int i = 1; i < m + 1;i++)scanf("%d", &a[i]);
32 | 	a[m + 1] = n + 1;
33 | 	sort(all(a));
34 | 	m+=2;
35 | 	int mn = n + 1;
36 | 	for(int i = 1;i < m;i++){
37 | 		int d = a[i] - a[i - 1] - 1;
38 | 		if(d >= 1)mn = min(mn, d);
39 | 	}
40 | 	if(mn == n + 1){
41 | 		cout<<0<<endl;
42 | 		return 0;
43 | 	}
44 | 	ll ans = 0;
45 | 	for(int i = 1;i < m;i++){
46 | 		ll need = a[i] - a[i - 1] - 1;
47 | 		if(need >= 1)ans+=(need + mn - 1) / mn;
48 | 	}
49 | 	cout<<ans<<endl;
50 | }
51 | 
52 | 


--------------------------------------------------------------------------------
/AtCoder/abc185/e.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | #define ll long long int
 3 | #define pb push_back
 4 | #define endl '\n'
 5 | #define Endl '\n'
 6 | #define fi first
 7 | #define ii pair<int,int>
 8 | #define iil pair<ll,ll>
 9 | #define se second
10 | #define ld long double
11 | #define mod 0
12 | #define popcount __builtin_popcountll
13 | #define x0 zxcxzcsacasd
14 | #define x1 ghfghujfgfg
15 | #define y0 olkjhdnncvcv
16 | #define y1 bhvgrewm345345435
17 | #define debug(x) std::cerr<<#x<<": "<<(x)<<'\n'
18 | #define all(x) x.begin(), x.end()
19 | using namespace std;
20 | 
21 | int n, m;
22 | vector<int>a, b;
23 | int dp[1002][1002];
24 | int cal(int i, int j){
25 | 	if(i == n || j == m){
26 | 		return (n - i) + (m - j);
27 | 	}
28 | 	int &ret = dp[i][j];
29 | 	if(ret != -1)return ret;
30 | 	ret = 1000000;
31 | 	if(a[i] == b[j])ret = cal(i + 1, j + 1);
32 | 	ret = min(ret, 1 + cal(i + 1, j));
33 | 	ret = min(ret, 1 + cal(i, j + 1));
34 | 	ret = min(ret, 1 + cal(i + 1, j + 1));
35 | 	return ret;
36 | }
37 | int main(){
38 | 	cin >> n >> m;
39 | 	a.resize(n);
40 | 	b.resize(m);
41 | 	for(auto &x:a)scanf("%d", &x);
42 | 	for(auto &x:b)scanf("%d", &x);
43 | 	memset(dp, -1, sizeof dp);
44 | 	cout<<cal(0, 0)<<endl;
45 | }
46 | 
47 | 


--------------------------------------------------------------------------------
/AtCoder/abc178/f.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | #define ll long long int
 3 | #define pb push_back
 4 | #define endl '\n'
 5 | #define Endl '\n'
 6 | #define fi first
 7 | #define ii pair<int,int>
 8 | #define iil pair<ll,ll>
 9 | #define se second
10 | #define ld long double
11 | #define mod 1000000007
12 | #define popcount __builtin_popcountll
13 | #define x0 zxcxzcsacasd
14 | #define x1 ghfghujfgfg
15 | #define y0 olkjhdnncvcv
16 | #define y1 bhvgrewm345345435
17 | #define debug(x) std::cerr<<#x<<": "<<(x)<<'\n'
18 | #define all(x) x.begin(), x.end()
19 | using namespace std;
20 | 
21 | int main(){
22 | 	int n;
23 | 	cin>>n;
24 | 	vector<int>a(n), b(n), amid(n);
25 | 	vector<int>cnt(n + 1, 0);
26 | 	for(auto &x:a)scanf("%d", &x), cnt[x]++;
27 | 	for(auto &x:b)scanf("%d", &x), cnt[x]++;
28 | 	for(int i = 1;i<=n;i++){
29 | 		if(cnt[i]>n){
30 | 			cout<<"No"<<endl;
31 | 			return 0;
32 | 		}
33 | 	}
34 | 	reverse(all(b));
35 | 	int l = 0, r = n-1;
36 | 	for(int i=0;i<n;i++){
37 | 		if(a[i]==b[i]){
38 | 			if(b[l]!=a[i] && a[l]!=a[i]){
39 | 				swap(b[l], b[i]);
40 | 				l++;
41 | 			}else{
42 | 				swap(b[r], b[i]);
43 | 				r--;
44 | 			}
45 | 		}
46 | 	}
47 | 	cout<<"Yes"<<endl;
48 | 	for(int i=0;i<n;i++){
49 | 		assert(a[i]!=b[i]);
50 | 		cout<<b[i]<<" ";
51 | 	}
52 | }
53 | 
54 | 


--------------------------------------------------------------------------------
/AtCoder/abc179/e.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | #define ll long long int
 3 | #define pb push_back
 4 | #define endl '\n'
 5 | #define Endl '\n'
 6 | #define fi first
 7 | #define ii pair<int,int>
 8 | #define iil pair<ll,ll>
 9 | #define se second
10 | #define ld long double
11 | #define mod 1000000007
12 | #define popcount __builtin_popcountll
13 | #define x0 zxcxzcsacasd
14 | #define x1 ghfghujfgfg
15 | #define y0 olkjhdnncvcv
16 | #define y1 bhvgrewm345345435
17 | #define debug(x) std::cerr<<#x<<": "<<(x)<<'\n'
18 | #define all(x) x.begin(), x.end()
19 | using namespace std;
20 | void test_case(){
21 | 	
22 | }
23 | int main(){
24 | 	ll n, x, m;
25 | 	cin>>n>>x>>m;
26 | 	ll ans = x;
27 | 	map<int, int>id;
28 | 	vector<int>v;
29 | 	v.pb(x);
30 | 	ll rem = n - 1;
31 | 	for(int i=1;i<n;i++){
32 | 		ll a = v[i-1];
33 | 		id[a] = i - 1;
34 | 		a*=a;
35 | 		a = a%m;
36 | 		if(id.count(a)){
37 | 			int len = 0;
38 | 			ll sum = 0;
39 | 			int l = v.size();
40 | 			for(int j = id[a];j<l;j++){
41 | 				sum+=v[j];
42 | 				len++;
43 | 			}
44 | 			ll c = rem / len;
45 | 			ans+=c * sum;
46 | 			rem%=len;
47 | 			for(int j = id[a];rem;j++, rem--){
48 | 				ans+=v[j];
49 | 			}
50 | 			break;
51 | 		}
52 | 		rem--;
53 | 		ans+=a;
54 | 		v.pb(a);
55 | 	}
56 | 	cout<<ans<<endl;
57 | }
58 | 


--------------------------------------------------------------------------------
/Articles/Stress Testing/bad implementation/main.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int rnd(int a, int b){
 5 |     return a + rand() % (b - a + 1);
 6 | }
 7 | int generator(){
 8 |     // This function acts as a generator.
 9 |     int w = rnd(1, 100);
10 |     return w;
11 | }
12 | string solve(int w){
13 |     // This function acts as the WA solution to test.
14 |     if(w%2==0)return "YES";
15 |     return "NO";
16 | }
17 | 
18 | string bruteForce(int w){
19 |     // This function acts as the brute force solution.
20 |     for(int i=1;i<w;i++){
21 |         int j = w - i;
22 |         if(i%2==0 && j%2==0)return "YES";
23 |     }
24 |     return "NO";
25 | }
26 | void check(int w, string myAnswer, string correctAnswer){
27 |     // This function acts as the checker.
28 |     if(myAnswer == correctAnswer)return;
29 |     cout<<"Found the WA test"<<endl;
30 |     cout<<"W = "<<w<<endl;
31 |     cout<<"myAnswer = "<<myAnswer<<endl;
32 |     cout<<"correctAnswer = "<<correctAnswer<<endl;
33 |     exit(0);
34 | }
35 | int main() {
36 |     for(int i=1;;i++){
37 |         int w = generator();
38 |         string myAnswer = solve(w);
39 |         string correctAnswer = bruteForce(w);
40 |         check(w, myAnswer, correctAnswer);
41 |         cout<<"Passed test: "<<i<<endl;
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/AtCoder/abc178/d_Combinatorics.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | #define ll long long int
 3 | #define pb push_back
 4 | #define endl '\n'
 5 | #define Endl '\n'
 6 | #define fi first
 7 | #define ii pair<int,int>
 8 | #define iil pair<ll,ll>
 9 | #define se second
10 | #define ld long double
11 | #define mod 1000000007
12 | #define popcount __builtin_popcountll
13 | #define x0 zxcxzcsacasd
14 | #define x1 ghfghujfgfg
15 | #define y0 olkjhdnncvcv
16 | #define y1 bhvgrewm345345435
17 | #define debug(x) std::cerr<<#x<<": "<<(x)<<'\n'
18 | #define all(x) x.begin(), x.end()
19 | using namespace std;
20 | ll C[1010][3030];
21 | ll fac[6060];
22 | ll inv[6060];
23 | ll p(ll a, ll b){
24 | 	if(b==0)return 1;
25 | 	ll r = p(a, b/2);
26 | 	r*=r;
27 | 	r%=mod;
28 | 	if(b%2)r*=a;
29 | 	return r%mod;
30 | }
31 | ll get(int a, int b){
32 | 	ll ret = fac[a];
33 | 	ret*=inv[b];
34 | 	ret%=mod;
35 | 	ret*=inv[a-b];
36 | 	ret%=mod;
37 | 	return ret;
38 | }
39 | int main(){
40 | 	fac[0] = 1;
41 | 	inv[0] = 1;
42 | 	for(ll i=1;i<6060;i++){
43 | 		fac[i] = fac[i-1] * i;
44 | 		fac[i]%=mod;
45 | 		inv[i] = p(fac[i], mod - 2);
46 | 	}
47 | 	ll ans = 0;
48 | 	int s;
49 | 	cin>>s;
50 | 	for(int i = 1;i<=1000;i++){
51 | 		int r = s - 3 * i;
52 | 		if(r < 0)break;
53 | 		ans+=get(s - 2*i - 1, i-1);
54 | 		ans%=mod;
55 | 	}
56 | 	cout<<ans<<endl;
57 | }
58 | 
59 | 


--------------------------------------------------------------------------------
/AtCoder/abc178/e.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | #define ll long long int
 3 | #define pb push_back
 4 | #define endl '\n'
 5 | #define Endl '\n'
 6 | #define fi first
 7 | #define ii pair<int,int>
 8 | #define iil pair<ll,ll>
 9 | #define iii pair<pair<int, int>, int >
10 | #define iiil pair<pair<ll, ll>, ll >
11 | #define se second
12 | #define ld long double
13 | #define mod 1000000007
14 | #define popcount __builtin_popcountll
15 | #define x0 zxcxzcsacasd
16 | #define x1 ghfghujfgfg
17 | #define y0 olkjhdnncvcv
18 | #define y1 bhvgrewm345345435
19 | using namespace std;
20 | multiset<ll>ms[5];
21 | void add(ll x, ll y){
22 |     ms[1].insert(x + y);
23 |     ms[2].insert(-x + y);
24 |     ms[3].insert(-x - y);
25 |     ms[4].insert(x - y);
26 | }
27 | 
28 | ll query(ll x, ll y){
29 |     if(ms[1].empty())return -1;
30 |     ll ret = 0;
31 |     ret = max(ret, *ms[1].rbegin() + (-x - y));
32 |     ret = max(ret, *ms[2].rbegin() + (x - y));
33 |     ret = max(ret, *ms[3].rbegin() + (x + y));
34 |     ret = max(ret, *ms[4].rbegin() + (-x + y));
35 |     return ret;
36 | }
37 | ll a[1<<20];
38 | ll b[1<<20];
39 | int main(){
40 | 	int n;
41 | 	cin>>n;
42 | 	for(int i=0;i<n;i++){
43 | 		scanf("%lld%lld", &a[i], &b[i]);
44 | 		add(a[i], b[i]);
45 | 	}
46 | 	ll ans = 0;
47 | 	for(int i=0;i<n;i++){
48 | 		ans = max(ans, query(a[i], b[i]));
49 | 		add(a[i], b[i]);
50 | 	}
51 | 	cout<<ans<<endl;
52 | }
53 | 
54 | 


--------------------------------------------------------------------------------
/Articles/Polygon.CodeForces Tutorial/check.cpp:
--------------------------------------------------------------------------------
 1 | #include "testlib.h"
 2 | #include <bits/stdc++.h>
 3 | #define ll long long
 4 | using namespace std;
 5 | int n;
 6 | bool has[1010];
 7 | bool prime(int x){
 8 |     if(x == 1)return false;
 9 | 	for(int i = 2; i * i <= x;i++){
10 | 		if(x%i == 0)return false;
11 | 	}
12 | 	return true;
13 | }
14 | int readAns(InStream& stream) {
15 |     int ans = stream.readInt(1, 1000);
16 |     if(has[ans] == 0)return -1;
17 |     if(prime(ans) == 0)return 0;
18 |     return 1;
19 | }
20 | 
21 | int main(int argc, char * argv[]){
22 |     registerTestlibCmd(argc, argv);
23 |     int n = inf.readInt();
24 |     for(int i=0;i<n;i++){
25 | 		int x = inf.readInt();
26 | 		has[x] = 1;
27 | 	}
28 |     
29 |     int jans = readAns(ans);
30 |     int pans = readAns(ouf);
31 |     if(jans==0)quitf(_fail, "Jury answer Incorrect, The number is not prime!!!");
32 |     if(jans==-1)quitf(_fail, "Jury answer Incorrect, the number is not from the input array!!!");
33 |     
34 |     if(pans==0)quitf(_wa, "participant answer Incorrect, The number is not prime.");
35 |     if(pans==-1)quitf(_wa, "participant answer Incorrect, the number is not from the input array.");
36 |     if (!ans.seekEof())quitf(_fail, "Jury answer contain extra tokens!!!");
37 |     if (!ouf.seekEof())quitf(_wa, "Participant answer contain extra tokens.");
38 |     quitf(_ok, "Passed all tests.");
39 | }
40 | 
41 | 
42 | 


--------------------------------------------------------------------------------
/Articles/Stress Testing/good implementation using checker/checker.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | #define pb push_back
 3 | using namespace std;
 4 | int a[22];
 5 | int b[22];
 6 | int n;
 7 | int readAns(ifstream &fin){
 8 |     int ans;
 9 |     fin>>ans;
10 |     if(ans==-1)return ans;
11 |     b[0] = ans;
12 |     for(int i=1;i<2*n;i++)fin>>b[i];
13 |     int s1 = 0, s2 = 0;
14 |     for(int i=0;i<n;i++){
15 |         s1+=b[i];
16 |         s2+=b[i+n];
17 |     }
18 |     if(s1==s2)return -2;                // Sums are equal
19 |     sort(b,b+2*n);
20 |     for(int i=0;i<2*n;i++){
21 |         if(a[i]!=b[i])return 0;         // Printing another array
22 |     }
23 |     return 1;                           // Correct answer
24 | }
25 | int main(int argc, char * argv[]){
26 |     ifstream fin("input_file", ifstream::in);
27 |     ifstream ans("myAnswer", ifstream::in);
28 |     ifstream cor("correctAnswer", ifstream::in);
29 |     fin>>n;
30 |     for(int i=0;i<2*n;i++)fin>>a[i];
31 |     sort(a,a+2*n);
32 |     int myAnswer = readAns(ans);
33 |     int correctAnswer = readAns(cor);
34 |     if(myAnswer==-2){
35 |         cout<<"WA Sums are equal"<<endl;
36 |         return -1;
37 |     }
38 |     if(myAnswer==0){
39 |         cout<<"WA Printing another array"<<endl;
40 |         return -1;
41 |     }
42 |     if(myAnswer == -1 && correctAnswer == 1){
43 |         cout<<"Brute force found a solution, but the code didn't find"<<endl;
44 |         return -1;
45 |     }
46 |     return 0;
47 | }
48 | 


--------------------------------------------------------------------------------
/AtCoder/abc185/f.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | #define ll long long int
 3 | #define pb push_back
 4 | #define endl '\n'
 5 | #define Endl '\n'
 6 | #define fi first
 7 | #define ii pair<int,int>
 8 | #define iil pair<ll,ll>
 9 | #define se second
10 | #define ld long double
11 | #define mod 0
12 | #define popcount __builtin_popcountll
13 | #define x0 zxcxzcsacasd
14 | #define x1 ghfghujfgfg
15 | #define y0 olkjhdnncvcv
16 | #define y1 bhvgrewm345345435
17 | #define debug(x) std::cerr<<#x<<": "<<(x)<<'\n'
18 | #define all(x) x.begin(), x.end()
19 | using namespace std;
20 | 
21 | int n, q;
22 | int a[300030];
23 | int tree[1 << 21];
24 | void build(int pos, int l, int r){
25 | 	if(l == r){
26 | 		tree[pos] = a[l];
27 | 		return;
28 | 	}
29 | 	int md = (l + r) / 2;
30 | 	build(2 * pos, l, md);
31 | 	build(2 * pos + 1, md + 1, r);
32 | 	tree[pos] = (tree[2 * pos] ^ tree[2 * pos + 1]);
33 | }
34 | void update(int pos, int l, int r, int tar, int val){
35 | 	if(l == r && l == tar){
36 | 		tree[pos] = val;
37 | 		return;
38 | 	}
39 | 	int md = (l + r) / 2;
40 | 	if(tar >= l && tar <= md)update(2 * pos, l, md, tar, val);
41 | 	else update(2 * pos + 1, md + 1, r, tar, val);
42 | 	tree[pos] = (tree[2 * pos] ^ tree[2 * pos + 1]);
43 | }
44 | int query(int pos, int l, int r, int st, int en){
45 | 	if(l > en || r < st)return 0;
46 | 	if(st <= l && en >= r){
47 | 		return tree[pos];
48 | 	}
49 | 	int md = (l + r) / 2;
50 | 	int x = query(2 * pos, l, md, st, en);
51 | 	int y = query(2 * pos + 1, md + 1, r, st, en);
52 | 	return (x ^ y);
53 | }
54 | int main(){
55 | 	cin >> n >> q;
56 | 	for(int i = 1 ; i <= n;i++)scanf("%d", &a[i]);
57 | 	build(1, 1, n);
58 | 	while(q--){
59 | 		int ty, x, y;
60 | 		scanf("%d%d%d", &ty, &x, &y);
61 | 		if(ty == 1){
62 | 			a[x] = (a[x] ^ y);
63 | 			update(1, 1, n, x, a[x]);
64 | 		}
65 | 		else cout<<query(1, 1, n, x, y)<<Endl;
66 | 	}
67 | }
68 | 
69 | 


--------------------------------------------------------------------------------
/Articles/monotonic queue.cpp:
--------------------------------------------------------------------------------
 1 | // #include "testlib.h"
 2 | #include <bits/stdc++.h>
 3 | #define ll long long
 4 | #define pb push_back
 5 | #define endl '\n'
 6 | #define Endl '\n'
 7 | #define fi first
 8 | #define ii pair<ll,ll>
 9 | #define se second
10 | #define double long double
11 | #define mod 1000000007
12 | #define popcount __builtin_popcountll
13 | const double PI = acos(-1.0);
14 | using namespace std;
15 | #define MXN 3005
16 | int n, m, a, b ;
17 | int h[MXN][MXN];
18 | ll temp[MXN][MXN];
19 | ll g0, x, y, z;
20 | 
21 | deque<ii>dq;
22 | void add(int val, int idx){
23 |     while(!dq.empty() && dq.back().first>=val){
24 |         dq.pop_back();
25 |     }
26 |     dq.push_back({val, idx});
27 | }
28 | void del(int idx){
29 |     if(!dq.empty() && dq.front().second==idx)dq.pop_front();
30 | }
31 | ll ans;
32 | void init(){
33 |     while(!dq.empty())dq.pop_front();
34 |     return;
35 | }
36 | 
37 | ll solve(){
38 |     for(int i=1;i<=n;i++){
39 |         init();
40 |         for(int j=1;j<=b;j++){
41 |             add(h[i][j], i);
42 |         }
43 |         int c = 1;
44 |         temp[i][c++] = dq.front().first;
45 |         for(int j=b+1;j<=m;j++){
46 |             del(i-b);
47 |             add(h[i][j], j);
48 |             temp[i][c++] = dq.front().first;
49 |         }
50 |     }
51 |     init();
52 |     for(int j=1;j<=(m-b+1);j++){
53 |         init();
54 |         for(int i=1;i<=a;i++){
55 |             add(temp[i][j], i);
56 |         }
57 |         ans+=dq.front().first;
58 |         for(int i=a+1;i<=n;i++){
59 |             del(i-a);
60 |             add(temp[i][j], i);
61 |             ans+=dq.front().first;
62 |         }
63 |     }
64 |     return ans;
65 | }
66 | void gen(){
67 |     for(int i=1;i<=n;i++){
68 |         for(int j=1;j<=m;j++){
69 |             h[i][j] = g0;
70 |             g0 = g0*x + y;
71 |             g0%=z;
72 |         }
73 |     }
74 | }
75 | int main(){
76 |     cin>>n>>m>>a>>b;
77 |     cin>>g0>>x>>y>>z;
78 |     gen();
79 |     cout<<solve()<<endl;
80 | }
81 | 


--------------------------------------------------------------------------------
/AtCoder/abc179/d.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | #define ll long long int
 3 | #define pb push_back
 4 | #define endl '\n'
 5 | #define Endl '\n'
 6 | #define fi first
 7 | #define ii pair<int,int>
 8 | #define iil pair<ll,ll>
 9 | #define se second
10 | #define ld long double
11 | #define mod 998244353
12 | #define popcount __builtin_popcountll
13 | #define x0 zxcxzcsacasd
14 | #define x1 ghfghujfgfg
15 | #define y0 olkjhdnncvcv
16 | #define y1 bhvgrewm345345435
17 | #define debug(x) std::cerr<<#x<<": "<<(x)<<'\n'
18 | #define all(x) x.begin(), x.end()
19 | using namespace std;
20 | int n, k;
21 | ll tree[1600010];
22 | ll lazy[1600010];
23 | void push(int pos, int l, int r){
24 | 	if(lazy[pos]==0)return;
25 | 	tree[pos] += lazy[pos]; // Update it
26 | 	tree[pos]%=mod;
27 | 	if(l != r) {
28 | 		lazy[pos*2] += lazy[pos]; // Mark child as lazy
29 | 		lazy[pos*2+1] += lazy[pos]; // Mark child as lazy
30 | 		lazy[2*pos]%=mod;
31 | 		lazy[2*pos + 1]%=mod;
32 | 	}
33 | 	lazy[pos] = 0;
34 | }
35 | void update(int pos, int l, int r, int st, int en, int v){
36 | 	if(l > en || st > r)return;
37 | 	push(pos, l, r);
38 | 	if(l>=st && r<=en){
39 | 		tree[pos]+=v;
40 | 		tree[pos]%=mod;
41 | 		if(l!=r){
42 | 			lazy[2*pos]+=v;
43 | 			lazy[2*pos + 1]+=v;
44 | 			lazy[2*pos]%=mod;
45 | 			lazy[2*pos + 1]%=mod;
46 | 		}
47 | 		return;
48 | 	}
49 | 	int md = (l+r)/2;
50 | 	update(2*pos, l, md, st, en, v);
51 | 	update(2*pos+1, md+1, r, st, en, v);
52 | }
53 | ll query(int pos, int l, int r, int tar){
54 | 	push(pos, l, r);
55 | 	if(l==r && l==tar)return tree[pos];
56 | 	int md = (l+r)/2;
57 | 	if(tar>=l && tar<=md)return query(2*pos, l, md, tar);
58 | 	return query(2*pos+1, md+1, r, tar);
59 | }
60 | 
61 | int main(){
62 | 	scanf("%d%d", &n, &k);
63 | 	vector<ii>segs(k);
64 | 	for(int i=0;i<k;i++){
65 | 		int l, r;
66 | 		scanf("%d%d", &l, &r);
67 | 		segs[i] = {l, r};
68 | 	}
69 | 	update(1, 1, 2*n, 1 , 1, 1);
70 | 	for(int i=1;i<=n;i++){
71 | 		for(auto s:segs){
72 | 			int l = s.fi, r = s.se;
73 | 			ll value = query(1, 1, 2 * n, i);
74 | 			value%=mod;
75 | 			update(1, 1, 2 * n, i + l, i + r, value);
76 | 		}
77 | 	}
78 | 	cout<<query(1, 1, 2 * n, n)%mod<<endl;
79 | }
80 | 


--------------------------------------------------------------------------------
/AtCoder/abc179/f.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | #define ll long long int
 3 | #define pb push_back
 4 | #define endl '\n'
 5 | #define Endl '\n'
 6 | #define fi first
 7 | #define ii pair<int,int>
 8 | #define iil pair<ll,ll>
 9 | #define se second
10 | #define ld long double
11 | #define mod 1000000007
12 | #define popcount __builtin_popcountll
13 | #define x0 zxcxzcsacasd
14 | #define x1 ghfghujfgfg
15 | #define y0 olkjhdnncvcv
16 | #define y1 bhvgrewm345345435
17 | #define debug(x) std::cerr<<#x<<": "<<(x)<<'\n'
18 | #define all(x) x.begin(), x.end()
19 | using namespace std;
20 | int n, q;
21 | struct Segment_tree{
22 | 	int tree[1<<20];
23 | 	int lazy[1<<20];
24 | 	void build(int pos, int l, int r){
25 | 		if(l == r){
26 | 			tree[pos] = 1;
27 | 			return;
28 | 		}
29 | 		int md = (l + r)/2;
30 | 		build(2*pos, l, md);
31 | 		build(2*pos + 1, md + 1, r);
32 | 		tree[pos] = 1;
33 | 	}
34 | 	void push(int pos, int l, int r){
35 | 		if(lazy[pos]==0)return;
36 | 		tree[pos] = max(tree[pos], lazy[pos]);
37 | 		if(l!=r){
38 | 			lazy[2 * pos] = max(lazy[2 * pos], lazy[pos]);
39 | 			lazy[2 * pos + 1] = max(lazy[2 * pos + 1], lazy[pos]);
40 | 		}
41 | 		lazy[pos] = 0;
42 | 	}
43 | 	void update(int pos, int l, int r, int s, int e, int v){
44 | 		if(l > e || s > r)return;
45 | 		push(pos, l, r);
46 | 		if(l >= s && r <= e){
47 | 			tree[pos] = max(tree[pos], v);
48 | 			if(l!=r){
49 | 				lazy[2 * pos] = max(lazy[2 * pos], v);
50 | 				lazy[2 * pos + 1] = max(lazy[2 * pos + 1], v);
51 | 			}
52 | 			return;
53 | 		}
54 | 		int md = (l + r)/2;
55 | 		update(2*pos, l, md, s, e, v);
56 | 		update(2*pos + 1, md + 1, r, s, e, v);
57 | 		tree[pos] = max(tree[2*pos], tree[2*pos + 1]);
58 | 	}
59 | 	int query(int pos, int l, int r, int tar){
60 | 		push(pos, l, r);
61 | 		if(l == r && l == tar){
62 | 			return tree[pos];
63 | 		}
64 | 		int md = (l + r)/2;
65 | 		if(tar >= l && tar <= md)return query(2 * pos, l, md, tar);
66 | 		else return query(2 * pos + 1, md + 1, r, tar);
67 | 	}
68 | }Xs, Ys;
69 | int main(){
70 | 	scanf("%d%d", &n, &q);
71 | 	ll black = 1ll * (n - 2) * (n - 2);
72 | 	Xs.build(1, 1, n);
73 | 	Ys.build(1, 1, n);
74 | 	while(q--){
75 | 		int t, x;
76 | 		scanf("%d%d", &t, &x);
77 | 		// x = n - x + 1;
78 | 		if(t == 1){
79 | 			int idx = Ys.query(1, 1, n, x);
80 | 			debug(idx);
81 | 			int diff = n - idx - 1;
82 | 			debug(diff);
83 | 			black-=diff;
84 | 			debug(black);
85 | 			Xs.update(1, 1, n, 1, idx, x);
86 | 			continue;
87 | 		}
88 | 		int idx = Xs.query(1, 1, n, x);
89 | 		debug(idx);
90 | 		int diff = n - idx - 1;
91 | 		debug(diff);
92 | 		black-=diff;
93 | 		debug(black);
94 | 		Ys.update(1, 1, n, 1, idx, x);
95 | 	}
96 | 	cout<<black<<endl;
97 | }
98 | 


--------------------------------------------------------------------------------
/Articles/Maximum Independent Set.cpp:
--------------------------------------------------------------------------------
  1 | // amiD
  2 | #include <bits/stdc++.h>
  3 | #define ll long long int
  4 | #define pb push_back
  5 | #define endl '\n'
  6 | #define Endl '\n'
  7 | #define fi first
  8 | #define ii pair<ll,ll>
  9 | #define se second
 10 | #define ld long double
 11 | #define mod 1000000007
 12 | #define popcount __builtin_popcountll
 13 | #define PI acos(-1.0)
 14 | #define MX 555
 15 | using namespace std;
 16 | vector<int>graph[MX];
 17 | int match[MX];
 18 | bool vis[MX];
 19 | int n, m;
 20 | 
 21 | bool dfs(int node){
 22 | 	if(vis[node])return 0;
 23 | 	vis[node] = 1;
 24 | 	for(auto nx:graph[node]){
 25 | 		if(match[nx]==-1 || dfs(match[nx])){
 26 | 			match[node] = nx;
 27 | 			match[nx] = node;
 28 | 			return 1;
 29 | 		}
 30 | 	}
 31 | 	return 0;
 32 | }
 33 | void cal(int node){
 34 |     if(vis[node])return;
 35 |     vis[node] = 1;
 36 |     if(node>n){     // node from the right side, can only traverse matched edge
 37 |         cal(match[node]);
 38 |         return;
 39 |     }
 40 |     for(auto nx:graph[node]){
 41 |         if(nx==match[node])continue;
 42 |         cal(nx);
 43 |     }
 44 | }
 45 | int main(){
 46 |     cin>>n>>m;
 47 |     for(int i=1;i<=n;i++){
 48 |         int k;
 49 |         scanf("%d", &k);
 50 |         for(int j=0;j<k;j++){
 51 |             char c;
 52 |             scanf(" %c", &c);
 53 |             int idx = (c-'A') + n + 1;
 54 |             graph[i].pb(n+c-'A' + 1);
 55 |             graph[n+c-'A' + 1].pb(i);
 56 |         }
 57 |     }
 58 |     memset(match, -1, sizeof match);
 59 |     while(1){
 60 |         memset(vis, 0, sizeof vis);
 61 |         bool cont = 0;
 62 |         for(int i=1;i<=n;i++){
 63 |             if(match[i]==-1)cont|=dfs(i);
 64 |         }
 65 |         if(cont==0)break;
 66 |     }
 67 |     memset(vis,0,sizeof vis);
 68 |     for(int i=1;i<=n;i++){
 69 |         if(match[i]!=-1)continue;       // matched node from the left side
 70 |         cal(i);
 71 |     }
 72 |     vector<int>mvc, MaxIS;
 73 |     for(int i=1;i<=n;i++){
 74 |         // Left side nodes
 75 |         // Visited nodes are part of the mvc
 76 |         // Unvisited nodes are part of the MaxIS
 77 |         if(vis[i])MaxIS.pb(i);
 78 |         else mvc.pb(i);
 79 |     }
 80 |     for(int i=n+1;i<=n+m;i++){
 81 |         // Right side nodes
 82 |         // Visited nodes are part of the MaxIS
 83 |         // Unvisited nodes are part of the mvc
 84 |         if(!vis[i])MaxIS.pb(i);
 85 |         else mvc.pb(i);
 86 |     }
 87 |     cout<<"MVC nodes:\n";
 88 |     for(auto x:mvc){
 89 |         if(x<=n)cout<<x<<" ";
 90 |         else cout<<char(x-n+'A'-1)<<" ";
 91 |     }
 92 |     cout<<endl;
 93 |     cout<<"MaxIS nodes:\n";
 94 |     for(auto x:MaxIS){
 95 |         if(x<=n)cout<<x<<" ";
 96 |         else cout<<char(x-n+'A'-1)<<" ";
 97 |     }
 98 | }
 99 | /*
100 | 4 5
101 | 2 A B
102 | 3 A C E
103 | 1 D
104 | 1 D
105 | */
106 | 
107 | 


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