蓝桥杯任意刷

受伤的皇后

#include <iostream>
#include <bits/stdc++.h>
using namespace std;
const int N=15;
int a[N][N];
int n,m;
int res=0;
int d[N];
bool ok(int x,int y){
    for(int i=1;i<x;i++){
        if(d[i]==y)return false;
        if(abs(x-i)==abs(y-d[i])){
            if(x-i<3)return false;
        }
    }
    return true;
    
}
void dfs(int u){//当前需要拜访第u行 
    if(u==n+1){
        res++; 
        return ;
    }
    for(int i=1;i<=n;i++){
        if(ok(u,i)){
            d[u]=i;
            dfs(u+1);
        }
    }
}
int main(){
scanf("%d",&n);
dfs(1);
printf("%d",res);
    return 0;
}

全球变暖（最大联通子集，一趟递归记得不要嵌套计数）

#include <iostream>
using namespace std;
const int N=1005;
char a[N][N];
bool vis[N][N];
int n,m;
int dx[5]={0,0,1,-1};
int dy[5]={1,-1,0,0};
int res=0;
int ans=0;
bool inside(int x,int y){
	return x>=1&&x<=n&&y>=1&&y<=n;
}
bool flag;
void dfs(int u,int v){
	if(!flag){
		int cnt=0;
		for(int i=0;i<4;i++){
			int cx=u+dx[i];
			int cy=v+dy[i];
			if(inside(cx,cy)&&a[cx][cy]=='#')cnt++;	
		} 
		if(cnt==4){
			ans++;
	//只是这样则 一个岛屿中存在x个点不会被淹没就会错判成残余x个岛，
//	其实只有一个 
			flag=true;
		}

	}
	
	for(int i=0;i<4;i++){
		int cx=u+dx[i];
		int cy=v+dy[i];
//		if(inside(cx,cy)&&a[cx][cy]=='#')cnt++;
		if(inside(cx,cy)&&!vis[cx][cy]&&a[cx][cy]=='#'){
			vis[cx][cy]=true;
			dfs(cx,cy);
		}
		
	} 
	
}
int main(){
	
	cin>>n;
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			cin>>a[i][j];
		}
	}
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			if(a[i][j]=='#'&&!vis[i][j]){
				vis[i][j]=true;//本可以不用vis，直接赋值 '.'，这里复习一下 
				res++;//最大联通子集的个数 
				flag=false;
				dfs(i,j);
			}
		}
	}
	printf("%d",res-ans);
	return 0;
} 

游园问题

输入输出样例
输入

WoAiLanQiaoBei

输出

AiLanQiao

这是普通的动态规划，时间复杂度 $O(n^2)$，能过70%

#include <iostream>
#include <bits/stdc++.h>
using namespace std;
const int N=1e6+5;
vector<string> str;
int dp[N];
int main(){
    string s,ss;
    cin>>s;
    int cnt=0;
    for(int i=0;i<s.size();i++){
        if(s[i]>='A'&&s[i]<='Z'){
            if(i)str.push_back(ss);
            ss="";
            ss+=s[i];
        }
        else ss+=s[i];
    }
    str.push_back(ss);
    int tail=0;//最长子序列最后一个元素在原数组str中的位置
    int len=0;
    for(int i=0;i<str.size();i++){
        dp[i]=1;
        for(int j=0;j<i;j++){
            if(str[i]>str[j]){
//                if(dp[j]+1>dp[i]){
//                    dp[i]=dp[j]+1;
//                }
                dp[i]=max(dp[j]+1,dp[i]);
            }
        }
        if(dp[i]>=len){//不加等号正确率直降10%
//        如果只是求最长子序列的长度，无需加等号，但要求最小字典序的最长子序列
//        为什么此时 长度为len，末尾元素str[i]一定小于 先前遇见的
//		长度为len 末尾元素为str[j]
//        反证法，如果str[j](长度为len)<str[i],那么此时长度一定大于len而不会等于
            len=dp[i];
            tail=i;
            //记录最长子序列的长度 和 最长子序列最后一个元素在原数组中的位置
        }
    }
//    知道原数组中每一个元素 作为子序列末尾元素对应的子序列长度
//    知道最长子序列的长度和末尾元素在原数组中的位置tail，就可以 从tail开始
//	反向遍历原数组，进而找 对应着长度为len-1子序列的最后一个元
    string res="";
    for(int i=tail;i>=0;i--){
        if(dp[i]==len){
            len--;
//            res+=str[i];//这样的话还得 reverse(res.begin(),res.end());
            res=str[i]+res;
        }
    }
   cout<<res;
    return 0;
}

题目意思，给定一串游客字符串，给定的顺序是预约顺序
需要从中选取尽可能多的游客（按游客字典序上升），按预约顺序输出选取的游客

如何保证队列中最后存放的就是最长上升子序列
首先假设队列Q中有一个元素 str【1】

遍历str数组， str【i】> Q.back(),则 str【i】插入队列Q（步骤一）

str【i】< Q.back(),则str【i】可能会小于Q.back()以及
其之前的(按照这种插入Q的方式，Q中元素一定是升序排列的)
那么str【i】应该放在队列中哪个位置->Q中大于str【i】的第一个元素的位置(步骤二)
(反证法可以证明Q中元素是升序的，可以进行二分)

但还没搞懂这贪心怎么证，贪心的道理倒是很容易清楚
队列Q是一路贪心的结果，具有最优子结构(maybe)
首先铁律是上升子序列要尽可能长（步骤一）

相同长度的上升子序列，要尽量保证每一个元素都尽可能小
（在不打乱上升性质的前提下）（动态规划实现的细节就是
相同长度的上升子序列的最大元素应该是尽可能小）(步骤二)
这里最后的队列Q ，可以做到长度为k且最大元素最小的子序列 就是Q(1~k)

（“我们这么理解，同样长度的子序列，是不是末尾的人越矮，
后面可以接着排队的人越多呢？所以这个就是贪心的精髓。”）

如果没理解错的话，拥有了队列Q可以，随时获取 给定长度的最小字典值的上升子序列
而正因为拥有这种性质（长度k-1的子序列字典值越小，更可能获得更长的子序列）

---

错了，Q队列存放的就是 Q[i]对应的是 长度为i的子序列的最小末尾元素
Q队列根本不是一个完整的最长子序列

好吧，转了一圈还是不知道为什么 遍历str去让更新Q就可以得到Q

#include <iostream>
#include <bits/stdc++.h>
using namespace std;
const int N=1e6+5;
vector<string> str;
vector<string> Q;
int main(){
    string s,ss;
    cin>>s;
    int cnt=0;
    for(int i=0;i<s.size();i++){
        if(s[i]>='A'&&s[i]<='Z'){
            if(i)str.push_back(ss);
            ss="";
            ss+=s[i];
        }
        else ss+=s[i];
    }
    str.push_back(ss);

    Q.push_back(str[0]);
     
    vector<int> len;
    len.push_back(1); //Q[0]是长度为1的子序列对应的最后一个元素 
    
    for(int i=1;i<str.size();i++){
        if(str[i]>Q.back()){
            Q.push_back(str[i]);
            len.push_back(Q.size());
        }
        else{
        
			
		    int l=0,r=Q.size()-1;
            while(l<r){
                int mid=(l+r)/2;
                if(Q[mid]>=str[i]){//替换掉Q中第一个大于等于str[i]的元素
//				二分的判断条件要根据题意来决定，不能每次都替换绝对大于她的 可能
//				比如  str[i]是6 ，Q 有一段是 5 6 7 8，不能替换7而应该是6
                    r=mid;
                }
                else l=mid+1;
            }
            Q[l]=str[i];
            len.push_back(l+1);
        } 
    }
    //	题目要求按预约顺序输出，于是最后按字典序排列的Q用不上
//	相当于需要输出路径，
//	最后得到的有最长子序列的长度sz,
//	可以记录 
//	str中每个元素作为子序列最后一个元素的子序列长度,其实也就是str中
//	被选中最后放在Q中的元素 在Q中的位置，可能会有多个str中的元素曾
//	试图摆放在Q的同一个位置，但是根据步骤二，一定是str中更后面的元素
//	最终成功留在Q中 
//	遍历看str中哪个元素对应的是 长度为sz的子序列的最后一个元素 
//	应该从后往前遍历str(更大的长度对应的最后一个元素一定在后面)
//	
//	记录str中被选中元素在Q中的位置 或者 记录 Q中选中元素在str中的位置 
    int sz=Q.size();
    int p=str.size()-1;
    vector<string> res;

    while(sz){
        if(len[p]==sz){
            sz--;//接下来找Q[sz-1]对应的str中的元素 
            res.push_back(str[p]);  
        }
        p--;
    } 
    for(int i=Q.size()-1;i>=0;i--){
        cout<<res[i];
    }
    return 0;
}

#include <iostream>
#include <bits/stdc++.h>
using namespace std;
const int N=1e6+5;
vector<string> str;
vector<string> Q;
int main(){
    string s,ss;
    cin>>s;
    int cnt=0;
    for(int i=0;i<s.size();i++){
        if(s[i]>='A'&&s[i]<='Z'){
            if(i)str.push_back(ss);
            ss="";
            ss+=s[i];
        }
        else ss+=s[i];
    }
    str.push_back(ss);

    Q.push_back(str[0]);
     
    vector<int> pos;
    pos.push_back(0); //Q[0]是长度为1的子序列对应的最后一个元素 
    
    for(int i=1;i<str.size();i++){
        if(str[i]>Q.back()){
            Q.push_back(str[i]);
            pos.push_back(Q.size()-1);
        }
        else{
        
			
		    int l=0,r=Q.size()-1;
            while(l<r){
                int mid=(l+r)/2;
                if(Q[mid]>=str[i]){//替换掉Q中第一个大于等于str[i]的元素
//				二分的判断条件要根据题意来决定，不能每次都替换绝对大于她的 可能
//				比如  str[i]是6 ，Q 有一段是 5 6 7 8，不能替换7而应该是6
                    r=mid;
                }
                else l=mid+1;
            }
            Q[l]=str[i];
            pos.push_back(l);
        } 
    }


//	记录str中被选中元素在Q中的位置 或者 记录 Q中选中元素在str中的位置 
    int sz=Q.size();
    int p=str.size()-1;
    vector<string> res;

    while(sz){
        if(pos[p]+1==sz){//len[p]代表str[p]在Q中的位置 从0存储 子序列最末尾元素的位置+1=子序列长度
            sz--;//接下来找Q[sz-1]对应的str中的元素 
            res.push_back(str[p]);  
        }
        p--;
    } 
    for(int i=Q.size()-1;i>=0;i--){
        cout<<res[i];
    }
    return 0;
}

错误输出路径

#include <iostream>
#include <bits/stdc++.h>
using namespace std;
const int N=1e6+5;
vector<string> str;
vector<string> Q;
int main(){
    string s,ss;
    cin>>s;
    int cnt=0;
    for(int i=0;i<s.size();i++){
        if(s[i]>='A'&&s[i]<='Z'){
            if(i)str.push_back(ss);
            ss="";
            ss+=s[i];
        }
        else ss+=s[i];
    }
    str.push_back(ss);

    Q.push_back(str[0]);
     
    vector<int> pos;
	pos.push_back(0);
//    pos.push_back(0); //Q[0]是长度为1的子序列对应的最后一个元素 
//    string pos[N];
    for(int i=1;i<str.size();i++){
        if(str[i]>Q.back()){
            Q.push_back(str[i]);
//            pos[Q.size()-1]=i;
				pos.push_back(i);
        }
        else{	
		    int l=0,r=Q.size()-1;
            while(l<r){
                int mid=(l+r)/2;
                if(Q[mid]>=str[i]){//替换掉Q中第一个大于等于str[i]的元素
//				二分的判断条件要根据题意来决定，不能每次都替换绝对大于她的 可能
//				比如  str[i]是6 ，Q 有一段是 5 6 7 8，不能替换7而应该是6
                    r=mid;
                }
                else l=mid+1;
            }
            Q[l]=str[i];
            pos[l]=i;
        } 
    }


//	记录str中被选中元素在Q中的位置 或者 记录 Q中选中元素在str中的位置 
	for(int i=0;i<Q.size();i++){
//		cout<<str[pos[i]];
cout<<Q[i];
	}
   
    return 0;
}

另一种输出路径，只过了20%，耐心耗尽

#include <iostream>
#include <bits/stdc++.h>
using namespace std;
const int N=1e6+5;
vector<string> str;
vector<string> Q;
int main(){
    string s,ss;
    cin>>s;
    int cnt=0;
    for(int i=0;i<s.size();i++){
        if(s[i]>='A'&&s[i]<='Z'){
            if(i)str.push_back(ss);
            ss="";
            ss+=s[i];
        }
        else ss+=s[i];
    }
    str.push_back(ss);

    Q.push_back(str[0]);
     
//    vector<int> pos;
//    pos.push_back(0); 
    int pos[N];
    pos[0]=0;//Q[0]对应的是str[0]中的0位置
    int pre[N];
    memset(pre,-1,sizeof(pre));
    for(int i=1;i<str.size();i++){
        if(str[i]>Q.back()){
            Q.push_back(str[i]);
            
            pos[Q.size()-1]=i;
            pre[i]=pos[Q.size()-2];
        }
        else{
		    int l=0,r=Q.size()-1;
            while(l<r){
                int mid=(l+r)/2;
                if(Q[mid]>=str[i]){//替换掉Q中第一个大于等于str[i]的元素
//				二分的判断条件要根据题意来决定，不能每次都替换绝对大于她的 可能
//				比如  str[i]是6 ，Q 有一段是 5 6 7 8，不能替换7而应该是6
                    r=mid;
                }
                else l=mid+1;
            }
            Q[l]=str[i];
            pos[l]=i;
            pre[i]=pos[l-1];
        } 
    }

  	int f=pos[Q.size()-1];
    stack<int> sta;
    while(pre[f] != -1){
        sta.push(f);
        f = pre[f];
    }
    sta.push(f);
    while(!sta.empty()){
        cout<<str[sta.top()];
        sta.pop();
    }
    return 0;
}

正解这种输出路径的方法

#include <bits/stdc++.h>
using namespace std;

char members[999995][12];
char * b[999995];
int p[999995];
int path[999995];

bool cmp(char * x, char * y){
    while ( (*x>='a' && *x<='z' || *x>='A' && *x<='Z') && (*y>='a' && *y<='z' || *y>='A' && *y<='Z') ){
        if (*x < *y) return true;
        if (*x > *y) return false;
        x++;
        y++;
    }
    if (*y != 0) return true;
    return false;
}

int find(int ll, int rr, char * s){
    int mid = (ll+rr)/2;
    while (ll<rr){
        if ( cmp(b[mid], s) ){
            ll=mid+1;
        } else {
            rr=mid;
        }
        mid = (ll+rr)/2;
    }
    return ll;
}

int main(){
    memset(path, -1, sizeof(path)-1);
    char x;
    x = getchar();
    int i=-1;
    int j=0;
    while( x >= 'a' && x <= 'z' || x >= 'A' && x <= 'Z' ){
        if ( x >= 'A' && x <= 'Z' ){
            i++;
            members[i][0] = x;
            j=1;
        } else {
            members[i][j] = x;
            j++;
        }
        x = getchar();
    }
    b[0] = members[0];
    p[0] = 0;
    int r=0;
    for (int k=1;k<=i;k++){
        if ( cmp(b[r], members[k]) ){
            r++;
            b[r] = members[k];
            p[r] = k;
            path[k] = p[r-1];
        } else {
            int pos = find(0, r, members[k]);
            if (pos > 0) path[k] = p[pos-1];
            b[pos] = members[k];
            p[pos] = k;
        }
    }
    int f=p[r];
    stack<int> sta;
    while(path[f] != -1){
        sta.push(f);
        f = path[f];
    }
    sta.push(f);
    while(!sta.empty()){
        cout<<members[sta.top()];
        sta.pop();
    }
    return 0;
}

解法二用普通数组k可以AC但在dev上崩了，用vector就可以
参考博文
力扣贪心解释
线段树解法

金额查错

一是要去重，二是小的要先去，先递归进 st【u】=true 的分支

#include<bits/stdc++.h>
using namespace std;
const int N=105;
int a[N];
bool f[N];
	int m,n;
	int sum=0;
void dfs(int u,int s){
		
	if(u==n){
	if(s==sum-m){
			for(int i=0;i<n;i++)if(f[i])cout<<a[i]<<" ";
			cout<<endl;
			return;
		}
		return ;
	}

//	出现了两次 3 4 去重，如果数组中没有重复数组选择是不会重复的
//	可以用map存储每次f数组，数组中有两个3，这是根源，但是别忘了a数组是排序好了的
  		if(u<n&&u > 1) {
		    if(a[u]==a[u-1]&&f[u-1]==false) {
		      u++;
		    }
  		}//这样可以确保 要么都选 要么只选相同中的第一个
  		
  	f[u]=true;//金额按照从小到大排列 一定是 先取小的，小的数要先取
	dfs(u+1,s+a[u]);
	
	f[u]=false;
	dfs(u+1,s);
	
	
}
int main(){

	cin>>m>>n;
	
	for(int i=0;i<n;i++){
		cin>>a[i];
		sum+=a[i];
	}
	sort(a,a+n);
	dfs(0,0);
	
	return 0;
}

如果小的数先不取，结果乱套了，选的数超过了m，即使让s>m时推出递归也无济于事
所以还是把小的先取，先递归进 st【u】=true 的分支

蓝肽子序列（最长公共子序列）

动态规划考虑到 下标-1的位置 不能越界（下届），用vector数组时可以先push 下标为0处任何一个值

#include<bits/stdc++.h>
using namespace std;
const int N=1005;
vector<string> s1,s2;
int dp[N][N];
int main(){//最长公共子序列
    string str1,str2;
    cin>>str1>>str2;
    string ss="*";
    s1.push_back(ss);
    s2.push_back(ss);
    ss="";
    for(int i=0;i<str1.size();i++){
        if(str1[i]>='A'&&str1[i]<='Z'){
            if(i){
                s1.push_back(ss);
                ss="";
                
            }
            ss+=str1[i];
        }
        else ss+=str1[i];
    }
    s1.push_back(ss);
    ss="";
    for(int i=0;i<str2.size();i++){
        if(str2[i]>='A'&&str2[i]<='Z'){
            if(i){
                s2.push_back(ss);
                ss="";
                
            }
            ss+=str2[i];
        }
        else ss+=str2[i];
    }
    s2.push_back(ss);
    for(int i=1;i<s1.size();i++){
        for(int j=1;j<s2.size();j++){
            if(s1[i]==s2[j]){
                dp[i][j]=dp[i-1][j-1]+1;
                
            }
            else dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
        }
    }
    cout<<dp[s1.size()-1][s2.size()-1];
    return 0;
}

123(二分)

#include<bits/stdc++.h>
using namespace std;
const int N=1500000;
#define ll long long int
ll a[N];//前缀长度
ll sum[N];//前缀和

ll preSum(ll x){
	ll l=1,r=N;//从小往大找，左边界一定要合法，一开始l取成0 1~？区间的求解就会出错,而从右往左这个左边界就，，反正能过
	while(l<r){
		ll mid=(l+r)>>1;从小往大找
		if(a[mid]<x){//找到 a[mid]>=x 且a[mid-1]<x,那么下标x就在第mid行
			l=mid+1;
		}
		else r=mid;
//		ll  mid = l + r + 1 >> 1;//从大往小找
//        if (a[mid] > x) r = mid - 1;//找到 a[mid]<=x 且a[mid+1]>x,那么下标x就在第mid行
//        else l = mid;
	}
//	return sum[l] + a[x - a[l]];
	return sum[l-1]+a[x-a[l-1]];
}
int main(){//最长公共子序列
	int T;
	cin>>T;
//	行数i,(1+i)*i/2<=1e12  i<=sqrt(2)* 1e6 < 150000 序列的长度小于150000
	for(int i=1;i<N;i++){
		a[i]=a[i-1]+i;
		sum[i]=sum[i-1]+a[i];
//		注意前i行的长度 的值 恰好等于 第i行的和
	}
	ll  l,r;
	while(T--){
		scanf("%lld %lld",&l,&r);
		printf("%lld\n",preSum(r)-preSum(l-1));
	}
    return 0;
}

#include<bits/stdc++.h>
using namespace std;
const int N=1500000;
#define ll long long int
ll a[N];//前缀长度
ll sum[N];//前缀和

ll preSum(ll x){
	ll l=1,r=N;//从小往大找，左边界一定要合法，一开始l取成0 1~？区间的求解就会出错
	while(l<r){
	
		ll  mid = l + r + 1 >> 1;//从大往小找
        if (a[mid] > x) r = mid - 1;//找到 a[mid]<=x 且a[mid+1]>x,那么下标x就在第mid行
        else l = mid;
	}
	return sum[l] + a[x - a[l]];
}
int main(){//最长公共子序列
	int T;
	cin>>T;
//	行数i,(1+i)*i/2<=1e12  i<=sqrt(2)* 1e6 < 150000 序列的长度小于150000
	for(int i=1;i<N;i++){
		a[i]=a[i-1]+i;
		sum[i]=sum[i-1]+a[i];
//		注意前i行的长度 的值 恰好等于 第i行的和
	}
	ll  l,r;
	while(T--){
		scanf("%lld %lld",&l,&r);
		printf("%lld\n",preSum(r)-preSum(l-1));
	}
    return 0;
}