对于x，y，x=y（mod m）等价于（x-y）mod m=0，即如果m是|x-y|的因子，那么x，y在模m的意义下同余

所以对于某个k值（k是n的因子，一个一个枚举即可），如果存在m大于等于2，满足a1，a1+k，a1+2 * k…在模m的意义下同余，a2，a2+k，a2+2 * k…在模m的意义下同余…那么k就是一个合法解，答案就加1，也就是说每隔k个的在模m的意义下同余，所以直接从头遍历，看其和其后第k个即可，然后都是模m等于0，所以m需要是它们所有的公因数，故求一个最大公因数，如果大于等于2的话就可以

还一种情况，就是每隔k个数都相等，那么最大公因数就是0，也是可行的

trick：

1.对于x，y，x=y（mod m）等价于（x-y）mod m=0，即如果m是|x-y|的因子，那么x，y在模m的意义下同余

2.a1，a1+k，a1+2 * k…在模m的意义下同余，a2，a2+k，a2+2 * k…在模m的意义下同余…也就是说每隔k个的在模m的意义下同余，所以直接从头遍历，看其和其后第k个是否同余即可，由于都是模m为0，所以m是每差k个的两数之差的绝对值的公因数

3.gcd（a，b），令a等于0，那么结果就是b，所以求很多数的最大公因数时，可以初始化为0，这样比较好，注意gcd为0的情况

#include<bits/stdc++.h>
#define endl '\n'
#define int long long
using namespace std;
const int N=2e5+10;
int a[N];
int n;
int gcd(int a,int b){if(b==0) return a;return gcd(b,a%b);
}
void solve() {cin>>n;for(int i=1;i<=n;i++) cin>>a[i];int ans=0;for(int k=1;k<=n;k++){//枚举kif(n%k==0){int tmp=0;for(int i=1;i+k<=n;i++){tmp=gcd(tmp,abs(a[i+k]-a[i]));}if(tmp>=2||tmp==0) ans++;}}cout<<ans<<endl;
}
signed main() {ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);int t=1;cin>>t;while(t--) {solve();}return 0;
}

一共有n个人
ai代表第i个人的起始位置，bi代表第i个人的结束位置（所有a，b数组的数均不同）
ai小于bi

均匀速
不存在追的上，只有它的终点大于（不存在等于）另一个时，才会相遇
通过手玩发现，包含和被包含关系才会相遇一次

trick：

这就作为一个案例，当遇到统计区间包含的问题时，可以有以下几种方法

另外，有一些小知识点，在看题解的时候注意到的，set的erase时间复杂度为O（logn），vector的erase时间复杂度为O(n)

枚举左端点（从小到大），一边枚举，一边把枚举过的区间的右端点放到set里，看有几个右端点是大于当前右端点的（利用set的二分upperbound），就是有几个区间包含它，就打几次招呼，set中自带的二分函数时间复杂度为O（logn），这样总的时间复杂度是O（nlogn），照理说，这样是没问题的，但是有一个问题就是set自带的二分函数返回的是迭代器，然后想要获得位置的话需要distance(迭代器1，迭代器2)，它底层实现是遍历，也就是O（n），这样时间复杂度就超了，试了一下直接用迭代器减s.begin()是会报错的，这个方法就不能用了

#include<bits/stdc++.h>
#define endl '\n'
//#define int long long
using namespace std;
const int N=2e5+10;
int l[N],r[N];
int n;
struct node{int l,r;bool operator<(const node &W)const{return l<W.l;}
}q[N];
void solve() {cin>>n;for(int i=1;i<=n;i++) cin>>q[i].l>>q[i].r;sort(q+1,q+1+n);set<int>s;int ans=0;s.insert(q[1].r);for(int i=2;i<=n;i++){auto t=s.upper_bound(q[i].r);int d=distance(s.begin(),t);ans+=s.size()-d;s.insert(q[i].r);}cout<<ans<<endl;
}
int main() {ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);int t=1;cin>>t;while(t--) {solve();}return 0;
}

于是改用树状数组，但是有一个问题就是数的范围太大了，达到了1e9，要想用树状数组的话，这些数值本身作为一个位置，空间肯定爆了，所幸数的个数比较小，于是先离散化，这样的话空间就不会爆了

#include<bits/stdc++.h>
#define endl '\n'
#define int long long
using namespace std;
const int N=2e5+10;
int l[N],r[N];
int tr[N];
int n;
vector<int>alls;
int find(int x){int l=0,r=alls.size()-1;while(l<r){int mid=(l+r)/2;if(alls[mid]>=x) r=mid;else l=mid+1;}return l+1;
}
int lowbit(int x)
{return x & -x;
}
int sum(int x)//求x位置前的前缀和
{int res=0;while(x) res+=tr[x],x-=lowbit(x);return res;
}
void add(int x,int c)//在x的位置上加上常数c
{while(x<=n) tr[x]+=c,x+=lowbit(x);
}
struct node{int l,r;bool operator<(const node &W)const{return l<W.l;}
}q[N];
void solve() {cin>>n;memset(tr,0,sizeof tr);for(int i=1;i<=n;i++) cin>>q[i].l>>q[i].r;//离散化alls.clear();for(int i=1;i<=n;i++){alls.push_back(q[i].r);}sort(alls.begin(),alls.end());sort(q+1,q+1+n);int ans=0;int pos=find(q[1].r);add(pos,1);for(int i=2;i<=n;i++){pos=find(q[i].r);int d=sum(pos);ans+=i-1-d;add(pos,1);                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }cout<<ans<<endl;
}
signed main() {ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);int t=1;cin>>t;while(t--) {solve();}return 0;
}

还有其它的方法，就是我们只要将左端点从小到大排序，然后发现，只要右端点逆序就存在一个包含区间（就是说如果左端点小，但是右端点大，那么它就把一个区间包含住了），所以只要统计逆序对的数量即可，用归并排序

#include<bits/stdc++.h>
#define endl '\n'
#define int long long
using namespace std;
const int N=2e5+10;
int l[N],r[N];
int c[N];
int n;
int ans;
struct node{int l,r;bool operator<(const node &W)const{return l<W.l;}
}q[N];
void mergesort(int l,int r){if(l==r) return;int mid=(l+r)/2;mergesort(l,mid),mergesort(mid+1,r);int i=l,j=mid+1,k=0;while(i<=mid&&j<=r){if(q[i].r<=q[j].r) c[k++]=q[i++].r;else{c[k++]=q[j++].r;ans+=mid-i+1;}}while(i<=mid) c[k++]=q[i++].r;while(j<=r) c[k++]=q[j++].r;for(int i=l,k=0;i<=r;i++) q[i].r=c[k++];
}
void solve() {cin>>n;for(int i=1;i<=n;i++) cin>>q[i].l>>q[i].r;sort(q+1,q+1+n);ans=0;mergesort(1,n);cout<<ans<<endl;
}
signed main() {ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);int t=1;cin>>t;while(t--) {solve();}return 0;
}

无限集合生成：1在集合中，如果x在集合中，那么x*a和x+b都在集合中
问n是否在这个集合中

集合元素可以用$a^{k_1}$+$k_2$*b表示，然后枚举k1即可，指数级别，最多枚举30次

trick：

数学

1.关于数学运算，手玩+推数学式子

2.无限集合生成问题，问某个数是否在里面，集合会不断产生数，数量是及其庞大的，不可能将全部数构造出来，可以用一个式子表示集合中的元素

3.当出现幂次时，可以往暴力枚举去想，因为指数级别，枚举不了几次的

#include<bits/stdc++.h>
#define endl '\n'
#define int long long
using namespace std;
int n,a,b;
void solve() {cin>>n>>a>>b;int res=1;for(int i=0;i<=30;i++){if(res>n) break;if((n-res)%b==0){cout<<"Yes"<<endl;return;}res*=a;}cout<<"No"<<endl;
}
signed main() {ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);int t=1;cin>>t;while(t--) {solve();}return 0;
}

要求至少包含k个codeforces，要求序列长度最短

ccoddddeeeeefffooooooooorrccceeessss按顺序排总的个数即为c的个数o的个数…*s的个数，按顺序，个数只要相乘，这样长度相对较短

由于和一定差小积大，积一定差小和小，所以平均分乘积最大

trick：

和一定差小积大，积一定差小和小，当和一定时，平均分乘积最大，平均分的另一技巧：假设0到9共10个位置，从0到9循环放置1（因为总和什么的都不是定值，只知道大概一个上限 ）

#include<bits/stdc++.h>
#define endl '\n'
#define int long long
using namespace std;
int k;
string s="codeforces";
map<int,int>mp;
bool check(){int res=1;for(int i=0;i<10;i++){res*=mp[i];}if(res>=k) return true;return false;
}
void solve() {cin>>k;int cnt=0;mp.clear();while(1){mp[cnt]++;cnt++;if(cnt==10) cnt=0;if(check()) break;}for(int i=0;i<10;i++){for(int j=0;j<mp[i];j++){cout<<s[i];}}cout<<endl;
}
signed main() {ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);int t=1;
//    cin>>t;while(t--) {solve();}return 0;
}

长度为n的01字符串

将字符串分成最少数量的子序列（可以跳着，但相对顺序不变），使得每个子序列01交替

贪心 ，可以放就放，不能放就生成一个新的集合

那么如何快速知道能不能放呢？将可以放的都放在set里，然后如何set的个数不为0，那么表示可以放，每次取set的头就行了

trick：
假设前面已经产生了很多个集合了，然后如何快速确定当前遍历到的数是否可以放在前面的集合里，只要一边遍历一边把可以放的集合序号放在set里，如果set的元素个数不为0，说明可以放，然后取set的头就行

#include<bits/stdc++.h>
#define endl '\n'
#define int long long
using namespace std;
const int N=2e5+10;
int a[N];
int n;
string s;
void solve() {cin>>n>>s;int cnt=0;//集合的序号set<int>a0,a1;//a0表示可以放0,a1表示可以放1for(int i=0;i<n;i++){if(s[i]=='1'){if(a1.size()==0){cnt++;//开一个集合a0.insert(cnt);//集合cnt可以放0a[i]=cnt;}else{int x=*a1.begin();a1.erase(a1.begin());a0.insert(x);a[i]=x;}}else{if(a0.size()==0){cnt++;a1.insert(cnt);a[i]=cnt;}else{int x=*a0.begin();a0.erase(a0.begin());a1.insert(x);a[i]=x;}}}cout<<cnt<<endl;for(int i=0;i<n;i++) cout<<a[i]<<' ';cout<<endl;
}
signed main() {ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);int t=1;cin>>t;while(t--) {solve();}return 0;
}

长度为n的数组a（数[1,n]）

对于一个全排列
操作：对一个连续子序列，特殊交换元素（使得没有一个数处于原来的位置）
问最少需要几次可以有序，不会超过1e18

题目说证明过了次数不会超过1e18，就感觉好离谱，基本可以判定是唬人的了，次数应该很小

手玩，造复杂极端的样例，发现最多两次就可以，对于那些中间隔着些位置确定的数，需要花两次把它们复原，对于那些位置不正确的数，花一次，然后它们的最大值即最少次数

trick：

手玩之造复杂极端的样例发现了规律

#include<bits/stdc++.h>
#define endl '\n'
#define int long long
using namespace std;
const int N=2e5+10;
int a[N];
int n;
void solve() {cin>>n;for(int i=1;i<=n;i++) cin>>a[i];int l=-1,r=-1;for(int i=1;i<=n;i++){if(a[i]!=i){l=i;break;}}for(int i=n;i>=1;i--){if(a[i]!=i){r=i;break;}}if(l==-1||r==-1){cout<<0<<endl;return;}bool ok=false;for(int i=l;i<=r;i++){if(a[i]==i){ok=true;break;}}if(ok) cout<<2<<endl;else cout<<1<<endl;
}
signed main() {ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);int t=1;cin>>t;while(t--) {solve();}return 0;
}

给定一个01字符串s，一个整数x
重新构造字符串w

如果si为1，要么wi-x为1，要么 wi+x为1
如果si为0，如果i-x或者i+x存在，它们必须为0
一开始题目读反了，然后输出答案，发现如果有解的话，那么和答案一样
所以想到先构造出w，再反过来验证
如何构造：如果si为0，那么就把wi-x和wi+x设为0，其它均设为1

trick：

关于如何构造，使得检验后不符合就一定是无解

把必须一定的先填上一定的值，其它的可能值不固定，但是使得不仅满足条件，而且要过满，完全满足，这样，如果检验都不合法的话，一定无解

#include<bits/stdc++.h>
#define endl '\n'
#define int long long
using namespace std;
const int N=1e5+10;
string s;
int x;
char w[N];
void solve() {cin>>s>>x;int n=s.size();s=' '+s;for(int i=1;i<=n;i++) w[i]='1';for(int i=1;i<=n;i++){if(s[i]=='0'){if(i-x>=1) w[i-x]='0';if(i+x<=n) w[i+x]='0';}}//验证 for(int i=1;i<=n;i++){if((i-x>=1&&w[i-x]=='1')||(i+x<=n&&w[i+x]=='1')){if(s[i]!='1'){cout<<-1<<endl;return;}}else{if(s[i]!='0'){cout<<-1<<endl;return;}}}for(int i=1;i<=n;i++) cout<<w[i];cout<<endl;
}
signed main() {ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);int t=1;cin>>t;while(t--) {solve();}return 0;
}

给定相邻字符中1的个数的次数
构造01字符串，一定有解

tric：

构造题想到奇偶，包括奇偶位以及变量是奇数还是偶数的分类

#include<bits/stdc++.h>
#define endl '\n'
#define int long long
using namespace std;
int n0,n1,n2;
void solve() {cin>>n0>>n1>>n2;if(n1==0){if(n0) for(int i=0;i<n0+1;i++) cout<<0;else for(int i=0;i<n2+1;i++) cout<<1;cout<<endl;return;}if(n1%2==1){n1/=2;for(int i=0;i<n1;i++) cout<<"01";for(int i=0;i<n0+1;i++) cout<<0;for(int i=0;i<n2+1;i++) cout<<1;cout<<endl;}else{n1/=2;for(int i=0;i<n1;i++) cout<<"10";for(int i=0;i<n0;i++) cout<<0;for(int i=0;i<n2+1;i++) cout<<1;cout<<endl;}
}
signed main() {ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);int t=1;cin>>t;while(t--) {solve();}return 0;
}

长度为n的数组a（数[-1e9,1e9]，非 0）

插入一些数（任何数，无穷也行 ），使得所有连续子段的和都不为0

我只要插入一个无穷，那么包含它的连续子段和一定不为0
只要统计有几个连续子段和为0，然后在该段区间内插入数破坏掉就行，在外面插入是改变不了该段的和的

如何看连续子段和是否为0，利用前缀和，一边遍历一边统计， 然后记录前面出现过的前缀和 ，如果当前缀和前面出现过了，那么以当前遍历到的数为右端点的一段连续区间和为0，此时，我们只要在当前遍历到的数之前插入一个无穷大，那么就隔断了，然后全部清空，从当前的数重现开始统计前缀和

trick：

如何一边遍历一边统计连续子段和为0的区间个数：动态记录前缀和，一边遍历一边统计， 然后动态记录前面出现过的前缀和 （利用map），如果当前缀和前面出现过了，那么以当前遍历到的数为右端点的一段连续区间和为0，注意一开始要mp[0]=1

#include<bits/stdc++.h>
#define endl '\n'
#define int long long
using namespace std;
const int N=2e5+10;
int a[N];
int n;
void solve() {cin>>n;for(int i=1;i<=n;i++) cin>>a[i];int sum=0;//动态记录前缀和map<int,int>mp;//动态记录出现过的前缀和mp[0]=1;int ans=0;for(int i=1;i<=n;i++){sum+=a[i];if(mp[sum]){//出现了一个连续区间和为0ans++;sum=a[i];mp.clear();mp[0]=1;}mp[sum]=1;}cout<<ans<<endl;
}
signed main() {ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);int t=1;
//    cin>>t;while(t--) {solve();}return 0;
}

一共n个冰球，ai为第i个冰球的价格

只买便宜的冰球（价格小于左右两边）

将所有冰球重新排序，使得可以购买的冰球数量最大

造波谷，使得波谷数量最多
波峰和波谷必须交替出现
先拍个序，然后双指针，最大，最小，次大，次小，交替，因为有相同的数，所以这样不一定最多

可以通过奇偶位构造，将一半小的依次放在2，4，6，…，将后面的依次放在1，3，5，…

trick：

构造题，想到奇偶分位

#include<bits/stdc++.h>
#define endl '\n'
#define int long long
using namespace std;
const int N=1e5+10;
int a[N];
int ans[N];
int n;
void solve() {cin>>n;for(int i=1;i<=n;i++) cin>>a[i];sort(a+1,a+1+n);int x=n/2;multiset<int>s1,s2;for(int i=1;i<=x;i++) s1.insert(a[i]);for(int i=x+1;i<=n;i++) s2.insert(a[i]);int idx=2;while(s1.size()){ans[idx]=*s1.begin();s1.erase(s1.begin());idx+=2;}idx=1;while(s2.size()){ans[idx]=*s2.begin();s2.erase(s2.begin());idx+=2;}int res=0;for(int i=2;i<=n-1;i++){if(ans[i]<ans[i-1]&&ans[i]<ans[i+1]) res++;}cout<<res<<endl;for(int i=1;i<=n;i++) cout<<ans[i]<<' ';cout<<endl;
}
signed main() {ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);int t=1;
//    cin>>t;while(t--) {solve();}return 0;
}

给定一个n，n为2的次幂

然后0到n-1共n个数，将它们两两一组配对，每组两个数相与，使得每组加起来刚好等于k，无解输出-1

关于2的次幂的位运算（假设n为2的次幂）：

1.x & (n-1-x)=0

2.x&(n-1)=x

故当n-1不等于k时，就让n-1和k与，变成k

其它均两两与变为0

当n-1等于k时，可以让(n-1)&(n-2)=n-2，(n-3)&1=1，0 & 2=0，全部加起来，凑成n-1，即k，然后其它凑成0

trick：

关于2的次幂的位运算（假设n为2的次幂）：

1.x & (n-1-x)=0

2.x&(n-1)=x

分析：

n为2的次幂，即一个1后面都是0，n-1则去掉那个1，将后面的0全部变为1（也就是全1）

那么n-1-x就是将x 0，1翻转，所以x & (n-1-x)=0

由于n-1全部都是1，所以x保留原来的1，x原来为0的，进行与运算也还是0，所以x&(n-1)=x

另外，n-1为11111

n-2为11110，n-3为11101

#include<bits/stdc++.h>
#define endl '\n'
#define int long long
using namespace std;
typedef pair<int,int>PII;
int n,k;
void solve() {cin>>n>>k;vector<PII>ans;if(k!=n-1){if(k){ans.push_back({k,n-1});ans.push_back({0,n-k-1});}else ans.push_back({k,n-1});for(int i=1;i<n/2;i++){if(i==k||i==n-k-1) continue;
//			cout<<i<<' '<<n-1-i<<endl;ans.push_back({i,n-1-i});}for(auto v:ans) cout<<v.first<<' '<<v.second<<endl;return;}ans.push_back({n-1,n-2});ans.push_back({1,n-3});ans.push_back({0,2});for(int i=3;i<n/2;i++) ans.push_back({i,n-1-i});int res=0;map<int,int>mp;mp[n-1]++;mp[n-2]++;mp[1]++;mp[n-3]++;mp[0]++;mp[2]++;for(auto v:mp){if(v.second>1){cout<<-1<<endl;return;}}for(auto v:ans) res+=(v.first&v.second);if(res==k){for(auto v:ans) cout<<v.first<<' '<<v.second<<endl;}else cout<<-1<<endl;
}
signed main() {ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);int t=1;cin>>t;while(t--) {solve();}return 0;
}

共n个球队
每两个球队进行一场比赛，平局各得1分，赢的得3分，输的不得分

要求输出每场比赛结果，使得所有球队分数相同，平局最少
一定有解

每个球队打n-1场比赛
每个球队赢的场和输的场数都一样，然后每个球队就先赢x场，保证好之后，剩下的只能是平和输，确定好平，剩下的就是输了

如果n为奇数的话，那么就每个球队赢（n-1)/2次，输(n-1)/2次，如果n为偶数的话，只能全部平局，通过反证法得到的，不对，如果n为偶数的话，同奇数，加一个平局

#include<bits/stdc++.h>
#define endl '\n'
#define int long long
using namespace std;
typedef pair<int,int>PII;
int n;
void solve() {cin>>n;vector<vector<int>>e(n+1);if(n%2==0){int x=(n-1)/2;//每个球队赢x场for(int i=1;i<n;i++){int sum=0;//赢了几场for(int j=i+1;j<=n;j++){if(sum<x) e[i].push_back(1);else if(sum==x) e[i].push_back(0);else e[i].push_back(-1);sum++;}}}else{int x=(n-1)/2;//每个球队赢x场for(int i=1;i<n;i++){int sum=0;//赢了几场for(int j=i+1;j<=n;j++){if(sum<x) e[i].push_back(1);else e[i].push_back(-1);sum++;}}}for(int i=1;i<n;i++){for(auto v:e[i]){cout<<v<<' ';}}cout<<endl;
}
signed main() {ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);int t=1;cin>>t;while(t--) {solve();}return 0;
}

在左下角为顶点（0，0）,右上角为（n,m）的矩形区域中选择若干个点，满足点为整数，但是任意两点距离不为整数
问最多选取几个点（不能选取原点）

最多n*m个点，10000
我们选取的原则是任何两个点不能在同一行，也不能在同一列
从（n，0）开始，一直往左上方，直到超出边界

#include<bits/stdc++.h>
#define endl '\n'
#define int long long
using namespace std;
typedef pair<int,int>PII;
int n,m;
void solve() {cin>>n>>m;vector<PII>ans;int x=n,y=0;while(x>=0&&y<=m){ans.push_back({x,y});x--;y++;}cout<<ans.size()<<endl;for(auto v:ans) cout<<v.first<<' '<<v.second<<endl;
}
signed main() {ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);int t=1;
//    cin>>t;while(t--) {solve();}return 0;
}

无限大正方形被分成很多单元格
给单元格涂上灰色
beautiful：所有灰色单元格都要相连，每个灰色单元格相邻灰色单元格数量为偶数，刚好有n个灰色单元格它周围的单元格都被涂色

一种构造万能的构造方法就是斜着构造

trick：

矩阵构造形状不定，斜着构造是一种方向

#include<bits/stdc++.h>
#define endl '\n'
#define int long long
using namespace std;
typedef pair<int,int>PII;
int n;
void solve() {cin>>n;vector<PII>ans;for(int i=0;i<=n+1;i++) ans.push_back({i,i});for(int i=0;i<=n;i++){ans.push_back({i,i+1});ans.push_back({i+1,i});}cout<<ans.size()<<endl;for(auto v:ans) cout<<v.first<<' '<<v.second<<endl;
}
signed main() {ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);int t=1;
//    cin>>t;while(t--) {solve();}return 0;
}

长度为n的01字符串
n个戒指，0表示金，1表示银

找两个不同的连续子序列，长度至少是n的一半，将它们分别转化为10进制，保证两个数非互质，一定有解

当序列全为1时，只要选择[1,n/2]和[2,n/2+1]即可

当存在一个0时，有这样两种情况：

记第一个0的位置为pos

1010101->[pos,n]和[pos+1,n]

1111101->[1,pos]和[1,pos-1]

trick：

1.先考虑特殊的简单的情况，比如说先考虑全0和全1再考虑0和1都有，再比如说先考虑全是正数和全是负数再考虑正数和负数都有

2.如果构造题题目说一个数是另一个数的倍数，由于是我们自己构造，所以考虑特殊的，比如1和2

再比如说两个数互质，我们可以考虑特殊的2和3

#include<bits/stdc++.h>
#define endl '\n'
#define int long long
using namespace std;
int n;
string s;
void solve() {cin>>n>>s;s=' '+s;int pos=-1;for(int i=1;i<=n;i++){if(s[i]=='0'){pos=i;break;}}if(pos==-1){cout<<1<<' '<<n/2<<' ';cout<<2<<' '<<n/2+1<<endl;}else{if(pos<=n/2){cout<<pos<<' '<<n<<' ';cout<<pos+1<<' '<<n<<endl;}else{cout<<1<<' '<<pos<<' ';cout<<1<<' '<<pos-1<<endl;}}
}
signed main() {ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);int t=1;cin>>t;while(t--) {solve();}return 0;
}

给定一棵树，共n个节点，n-1条边

在n-1条边上填入0到n-2之间的整数，填入的所有数不同

mex（u，v）：从节点u到节点v经过的所有边上的整数的mex
使得所有的mex的最大值最小

找到度数最多的那个点，分支分别放0，1，2，…，其它随便放

#include<bits/stdc++.h>
#define endl '\n'
#define int long long
using namespace std;
typedef pair<int,int>PII;
const int N=1e5+10;
int d[N];
bool flag[N];
int n;
vector<vector<int>>e(N);
vector<int>ans;
int res[N];
map<PII,int>mp;
int idx;
void dfs(int u,int fa){flag[u]=true;if(fa!=-1) mp[{u,fa}]=mp[{fa,u}]=ans[++idx];for(auto v:e[u]){if(v==fa||flag[v]) continue;dfs(v,u);}
}
void solve() {cin>>n;memset(d,0,sizeof d);memset(flag,false,sizeof flag);ans.clear();mp.clear();for(int i=1;i<=n;i++) e[i].clear();vector<PII>c;for(int i=0;i<n-1;i++){int u,v;cin>>u>>v;c.push_back({u,v});e[u].push_back(v);e[v].push_back(u);d[u]++;d[v]++;}if(n==2){cout<<0<<endl;return;}int maxn=0;int maxi;for(int i=1;i<=n;i++){if(maxn<d[i]){maxn=d[i];maxi=i;}}if(maxn==2){ans.push_back(0);for(int i=2;i<=n-2;i++) ans.push_back(i);ans.push_back(1);idx=-1;for(int i=1;i<=n;i++){if(d[i]==1){dfs(i,-1);break;}}}else{mp[{maxi,e[maxi][0]}]=mp[{e[maxi][0],maxi}]=0;mp[{maxi,e[maxi][1]}]=mp[{e[maxi][1],maxi}]=1;mp[{maxi,e[maxi][2]}]=mp[{e[maxi][2],maxi}]=2;for(int i=3;i<=n-2;i++) ans.push_back(i);idx=-1;flag[maxi]=true;flag[e[maxi][0]]=true;flag[e[maxi][1]]=true;flag[e[maxi][2]]=true;for(auto v:e[e[maxi][0]]) if(!flag[v]) dfs(v,e[maxi][0]);for(auto v:e[e[maxi][1]]) if(!flag[v]) dfs(v,e[maxi][1]);for(auto v:e[e[maxi][2]]) if(!flag[v]) dfs(v,e[maxi][2]);for(int i=3;i<(int)e[maxi].size();i++) if(!flag[e[maxi][i]]) dfs(e[maxi][i],maxi);}for(int i=0;i<n-1;i++){res[i]=mp[{c[i].first,c[i].second}];}for(int i=0;i<n-1;i++) cout<<res[i]<<endl;
}
signed main() {ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);int t=1;
//    cin>>t;while(t--) {solve();}return 0;
}

给定一个n，问最少几个不同的有权数的和为k，无解输出-1

阶乘比2的幂次还要恐怖很多，15的阶乘就刚好已经超过1e12了

2的40次刚好超过1e12

通过贪心，从高到低选择，这样个数最少，如果最后不能刚好等于n，则无解 ，但这样是不对的，分解2的次幂可以这样做，因为一个数的二进制表示是唯一的，但是其它这样做不行

预先预处理阶乘

因为可选择的阶乘的个数比较少，所以直接二进制枚举选和不选（状压），然后选完阶乘之和(不能超过n)，剩下的数选2的幂次，只需要转化成2进制，看2进制表示下有几个1即可
那有没有可能无解，即选取的2的幂次和阶乘重复了，不可能！因为一个数表示成2进制是唯一的，可以看作一开始的数转化成若干个2的次幂，然后将一些2的次幂合成阶乘

样例中没有无解的情况，那么基本上就没有无解的情况了

trick：

1.样例中没有无解的情况，那么基本上就没有无解的情况了

2.通过贪心，从高到低选择，这样个数最少，如果最后不能刚好等于n，则无解 ，但这样是不对的，分解2的次幂可以这样做，因为一个数的二进制表示是唯一的，但是其它这样做不行

3.如果可选择的个数很少的话（比如 2的幂次，阶乘），可利用二进制枚举选与不选

#include <bits/stdc++.h>
#define endl '\n'
#define int long long
using namespace std;
int fac[100];
int n;
void solve() {cin >> n;int ans = 2e9;for (int i = 0; i < (1ll << 15); i++) { //二进制枚举int sum = 0;int cnt = 0;for (int j = 0; j < 15; j++) { //二进制表示共15位if ((i >> j) & 1) {sum += fac[j + 1];cnt++;}}int res = n - sum;if (res >= 0) {while (res) {if (res & 1) cnt++;res >>= 1;}ans = min(ans, cnt);}}cout << ans << endl;
}
signed main() {ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);int t = 1;fac[0] = 1;for (int i = 1; i <= 15; i++) fac[i] = fac[i - 1] * i;cin>>t;while (t--) {solve();}return 0;
}

5
5 0 0 2 4
用样例来解释题目
5,2,4已经存放好，剩下的为1和3，将剩下的1和3分别填入为0的位置，要求下标不能等于数值

trick：

要求下标不能等于数值，先随便填入，再行调整，对于那些下标等于数值的，进行移位即可

#include<bits/stdc++.h>
#define endl '\n'
#define int long long
using namespace std;
const int N=2e5+10;
int f[N];
int n;
void solve() {cin>>n;for(int i=1;i<=n;i++) cin>>f[i];set<int>s;for(int i=1;i<=n;i++) s.insert(i);vector<int>pos;for(int i=1;i<=n;i++){if(f[i]) s.erase(f[i]);else pos.push_back(i);}map<int,int>mp;for(auto v:pos){//先随便放进去,然后如果下标和值一样,那么就移位一下f[v]=*s.begin();s.erase(s.begin());}
//	for(int i=1;i<=n;i++) cout<<f[i]<<' ';
//	cout<<endl;
//	cout<<'='<<endl;vector<int>c;for(int i=1;i<=n;i++){if(f[i]==i){c.push_back(i);}}if(c.size()==0){for(int i=1;i<=n;i++) cout<<f[i]<<' ';cout<<endl;return;}if(c.size()==1){for(auto v:pos){if(v!=c[0]){swap(f[v],f[c[0]]);for(int i=1;i<=n;i++) cout<<f[i]<<' ';cout<<endl;return;}}}int tmp=f[c[0]];for(int i=0;i<(int)c.size()-1;i++){f[c[i]]=f[c[i+1]];}f[c[(int)c.size()-1]]=tmp;for(int i=1;i<=n;i++) cout<<f[i]<<' ';cout<<endl;
}
signed main() {ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);int t=1;
//    cin>>t;while(t--) {solve();}return 0;
}

长度为n的排列，1到n

qi是p1到pi的最大值，q数组已知，逆推得到字典序最小的p和字典序最大的p

q中第一次出现的，那么对应位置p就可以确定
字典序最小的，只要在空的位置依次从小到大填入
字典序最大的，需要二分找到未填的数字中小于后缀最大值的最大的那个

#include<bits/stdc++.h>
#define endl '\n'
#define int long long
using namespace std;
const int N=2e5+10;
int a[N];
int b[N],c[N];
bool flag[N];
int n;
void solve() {cin>>n;for(int i=1;i<=n;i++) cin>>a[i];memset(flag,false,sizeof flag);map<int,int>mp;set<int>s1,s2;for(int i=1;i<=n+1;i++) s1.insert(i),s2.insert(i);for(int i=1;i<=n;i++){if(!mp[a[i]]){s1.erase(a[i]);s2.erase(a[i]);flag[i]=true;}mp[a[i]]=1;}for(int i=1;i<=n;i++){if(flag[i]) b[i]=a[i];else{b[i]=*s1.begin();s1.erase(s1.begin());}}for(int i=1;i<=n;i++){if(flag[i]) c[i]=a[i];else{auto it=s2.lower_bound(a[i]);it--;c[i]=*it;s2.erase(it);}}for(int i=1;i<=n;i++) cout<<b[i]<<' ';cout<<endl;for(int i=1;i<=n;i++) cout<<c[i]<<' ';cout<<endl;
}
signed main() {ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);int t=1;cin>>t;while(t--) {solve();}return 0;
}

O（根号n）枚举n的因子，如果有两个以上因子，如果不是幂次的话，那么就可以通过中间变量，使得全部同一种颜色
否则，答案为最小的因子

#include<bits/stdc++.h>
#define endl '\n'
#define int long long
using namespace std;
int n;
bool check(int x){if(x<=1) return false;for(int i=2;i<=x/i;i++){if(x%i==0) return false;}return true;
}
void solve() {cin>>n;if(n==1){cout<<1<<endl;return;}if(check(n)){cout<<n<<endl;return;}set<int>s;for(int i=2;i<=n/i;i++){if(n%i==0){s.insert(i);s.insert(n/i);}}if(s.size()!=1){int x=*s.begin();int m=n;int cnt=0;while(m!=1){m/=x;if(!m) break;cnt++;}if(pow(x,cnt)==n){cout<<x<<endl;}else cout<<1<<endl;}else{cout<<*s.begin()<<endl;}
}
signed main() {ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);int t=1;
//    cin>>t;while(t--) {solve();}return 0;
}

n个元素
数组a为1到k，k到2*k-n
假设有一个大小为k的序列p，令b[i]=p[a[i]]来建立b
目标找到排列p，使得b中的逆序对数量小于等于a逆序对数量，并且b字典序最大
1到k，a[i]一定等于i，所以b[i]=p[a[i]]=p[i]，所以p和b是同一个数组
首先，要保证逆序对数量不增加，要使得字典序最大，需要把大的放前面，那么保持逆序对数量不变，也就是k到n全都不变，然后个数和k差几个，就在前面从1开始补几个

#include<bits/stdc++.h>
#define endl '\n'
#define int long long
using namespace std;
int n,k;
void solve() {cin>>n>>k;int x=n-k+1;//k,k-1,k-2...,n一共x个int y=k-(x-1);//第n个数为yfor(int i=1;i<y;i++) cout<<i<<' ';for(int i=k;i>=y;i--) cout<<i<<' ';cout<<endl;
}
signed main() {ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);int t=1;cin>>t;while(t--) {solve();}return 0;
}

将2/n表示成1/x+1/y+1/z，无解输出-1

2/n=1/n+1/(n+1)+1/(n*(n+1))

trick：

通过变量推x，y，z，想必x，y，z和n有关系，n变化，那么x，y，z也会变化，料想x，y，z是带n的

#include<bits/stdc++.h>
#define endl '\n'
#define int long long
using namespace std;
int n;
void solve() {cin>>n;if(n==1){cout<<-1<<endl;return;}cout<<n<<' '<<n+1<<' '<<n*(n+1)<<endl;
}
signed main() {ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);int t=1;
//    cin>>t;while(t--) {solve();}return 0;
}

长度为n的字符串s和t
问能否将字符串s变为t
操作：交换距离为k或者k+1的两个字符

#include<bits/stdc++.h>
#define endl '\n'
#define int long long
using namespace std;
int n,k;
string s,t;
void solve() {cin>>n>>k;cin>>s>>t;map<char,int>mp1,mp2;if(n-1<k){//没有元素可交换for(int i=0;i<n;i++){if(s[i]!=t[i]){cout<<"No"<<endl;return;}}cout<<"Yes"<<endl;return;}if(n-1==k){//只有第一个元素和最后一个元素可以交换if(s[0]!=t[0]) swap(s[0],s[n-1]);for(int i=0;i<n;i++){if(s[i]!=t[i]){cout<<"No"<<endl;return;}}cout<<"Yes"<<endl;return;}//元素以及元个数必须相等for(int i=0;i<n;i++) mp1[s[i]]++,mp2[t[i]]++;for(auto v:mp1){if(mp1[v.first]!=mp2[v.first]){cout<<"No"<<endl;return;}}//1到l,r到n均可以交换int l=n-k;int r=1+k;
//	cout<<l<<' '<<r<<endl;if(l<r){for(int i=l+1;i<=r-1;i++){if(s[i-1]!=t[i-1]){cout<<"No"<<endl;return;}}}cout<<"Yes"<<endl;
}
signed main() {ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);int t=1;cin>>t;while(t--) {solve();}return 0;
}

构造长度为n的数组a（数[-1000,1000]）
使得k个区间的和为正数，其余区间和为负数，一定有解

对于连续x个正数，和为正的区间个数为x*(x+1)/2
利用二分找到小于等于k的第一个x，首先要连续x个30，然后再补上k-x*(x+1)/2个30，记为res，利用最大的负数-1000在中间断开，这样有些数凑不出来
利用一个适当的负数在中间断，将前面好多30抵消掉，剩下res个30作为左端点，一直到该负数，和为正，剩下填最大的负数-1000

#include<bits/stdc++.h>
#define endl '\n'
#define int long long
using namespace std;
int n,k;
int cal(int x){return x*(x+1)/2;
}
void solve() {cin>>n>>k;if(k==0){for(int i=0;i<n;i++) cout<<-1<<' ';cout<<endl;return;}int l=0,r=n;while(l<r){int mid=(l+r+1)/2;if(cal(mid)<=k) l=mid;else r=mid-1;}int res=k-cal(l);int x=l-res;vector<int>ans;for(int i=1;i<=l;i++) ans.push_back(30);if(res==0){while((int)ans.size()<n) ans.push_back(-1000);for(int i=0;i<(int)ans.size();i++) cout<<ans[i]<<' ';cout<<endl;return;}if((int)ans.size()<n) {if(x==0) ans.push_back(-1);else ans.push_back(-x*31);}while((int)ans.size()<n) ans.push_back(-1000);for(int i=0;i<(int)ans.size();i++) cout<<ans[i]<<' ';cout<<endl;
}
signed main() {ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);int t=1;cin>>t;while(t--) {solve();}return 0;
}

给n个单元格上色
共m种颜色，第i种颜色必须用ai次
k个连续的单元格，颜色均不同

每k个连续的颜色必须不同，也就是说对于一种颜色，不能在连续k个中重复出现
k个为1组，假设有cnt组，那么同一种颜色需要分布在这k组中，依次一组一组放就行了，平均分配，特判一下最后一组不为k个的情况

trick：

着色问题，本质上是分配问题，将某种颜色分配到哪些组中，平均分配，将某种颜色从第一组开始，往后一组一组放

#include<bits/stdc++.h>
#define endl '\n'
#define int long long
using namespace std;
int n,m,k;
void solve() {cin>>n>>m>>k;vector<int>a(m+1);for(int i=1;i<=m;i++) cin>>a[i];int cnt=n/k;//一共cnt个完整的kint res=n%k;//最后余下几个单元格if(res==0){for(int i=1;i<=m;i++){if(a[i]>cnt){cout<<"No"<<endl;return;}}cout<<"Yes"<<endl;return;}int sum=0;for(int i=1;i<=m;i++){if(a[i]>cnt+1){cout<<"No"<<endl;return;}if(a[i]==cnt+1) sum++;}if(sum>res){cout<<"No"<<endl;return;}cout<<"Yes"<<endl;
}
signed main() {ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);int t=1;cin>>t;while(t--) {solve();}return 0;
}

将k个管子恰好放在n*m的矩阵中，一定有解

trick：

矩阵走蛇形，每次取若干个，遍历矩阵不是很方便，可以先按照蛇形遍历一遍，将其放入vector里，变成线性，然后就很方便了

#include <bits/stdc++.h>
#define endl '\n'
#define int long long
using namespace std;
typedef pair<int, int>PII;
int n, m, k;
void solve() {cin >> n >> m >> k;int flag = 1;vector<PII>ans;for (int i = 1; i <= n; i++) {if (flag) {for (int j = 1; j <= m; j++) {ans.push_back({i, j});}} else {for (int j = m; j >= 1; j--) {ans.push_back({i, j});}}flag ^= 1;}int idx = 0;int cnt = 0;if (cnt != k - 1) {for (int i = 0; i < (int)ans.size(); i += 2) {cout << 2 << ' ' << ans[i].first << ' ' << ans[i].second << ' ' << ans[i + 1].first << ' ' << ans[i + 1].second << endl;cnt++;if (cnt == k - 1) {idx = i + 2;break;}}}int sum = 0;for (int i = idx; i < (int)ans.size(); i++) sum++;cout << sum << ' ';for (int i = idx; i < (int)ans.size(); i++) cout << ans[i].first << ' ' << ans[i].second << ' ';cout << endl;
}
signed main() {ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);int t = 1;
//    cin>>t;while (t--) {solve();}return 0;
}

由小写字母a和b组成的两个长度均为n的字符串s和t
操作：将si和ti互换
使得s和t相等，问最少几次操作

所有字符个数必须是偶数，否则无解，输出-1
已经相等的不用管了，对于不相等的，分成两类，第一类是s中为a，t中为b，第二类是s中为b，t中为a，分别放在vector1和vector2中，先将各自偶数个进行配对，然后每类若都余下一个，则两者配对

trick：

对于1到n遍历，然后1，2配对，3，4配对，…，如果n为奇数，那就遍历到n-1，一直i+=2，别遍历到n

#include<bits/stdc++.h>
#define endl '\n'
#define int long long
using namespace std;
int n;
string s,t;
void solve() {cin>>n;cin>>s>>t;map<char,int>mp;for(int i=0;i<n;i++) mp[s[i]]++,mp[t[i]]++;if(mp['a']%2||mp['b']%2){cout<<-1<<endl;return;}vector<int>ans1,ans2;for(int i=0;i<n;i++){if(s[i]==t[i]) continue;if(s[i]=='a') ans1.push_back(i+1);else ans2.push_back(i+1);}if((int)ans1.size()%2==0){cout<<ans1.size()/2+ans2.size()/2<<endl;for(int i=0;i<(int)ans1.size();i+=2){cout<<ans1[i]<<' '<<ans1[i+1]<<endl;}for(int i=0;i<(int)ans2.size();i+=2){cout<<ans2[i]<<' '<<ans2[i+1]<<endl;}}else{cout<<ans1.size()/2+ans2.size()/2+2<<endl;if((int)ans1.size()>1){for(int i=0;i<(int)ans1.size();i+=2){cout<<ans1[i]<<' '<<ans1[i+1]<<endl;}for(int i=0;i<(int)ans2.size();i+=2){cout<<ans2[i]<<' '<<ans2[i+1]<<endl;}}cout<<ans1[(int)ans1.size()-1]<<' '<<ans1[(int)ans1.size()-1]<<endl;cout<<ans1[(int)ans1.size()-1]<<' '<<ans2[(int)ans2.size()-1]<<endl;}
}
signed main() {ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);int t=1;
//    cin>>t;while(t--) {solve();}return 0;
}

n * m个单元格
共k种颜色，ai为第i种颜色可以着色的最大单元格数
beautiful：每个单元格周围至少三个颜色和它相同
问能否使得图画beautiful

根据样例，每种颜色需要至少完整的两列或两行
分别讨论放列和放行

Codeforces Round #810 (Div. 1) A. Color the Picture 解题报告-CSDN博客

#include<bits/stdc++.h>
#define endl '\n'
#define int long long
using namespace std;
const int N=1e5+10;
int a[N];
int n,m,k;
void solve() {cin>>n>>m>>k;for(int i=1;i<=k;i++) cin>>a[i];int sum=0;bool ok=false;for(int i=1;i<=k;i++){if(a[i]/m>=2) sum+=a[i]/m;if(a[i]/m>=3) ok=true;}if(sum>=n){if(n%2==0) {cout<<"Yes"<<endl;return;}else{if(ok) {cout<<"Yes"<<endl;return;}}}sum=0;ok=false;for(int i=1;i<=k;i++){if(a[i]/n>=2) sum+=a[i]/n;if(a[i]/n>=3) ok=true;}if(sum>=m){if(m%2==0) {cout<<"Yes"<<endl;return;}else{if(ok) {cout<<"Yes"<<endl;return;}}}cout<<"No"<<endl;
}
signed main() {ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);int t=1;cin>>t;while(t--) {solve();}return 0;
}