提高课二刷疑难杂题

已于 2022-11-13 21:49:27 修改
阅读量323 收藏
点赞数
分类专栏： 蓝桥杯 文章标签： 算法
于 2022-04-22 21:37:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53203911/article/details/124355649
版权

方格取数

#include<bits/stdc++.h>
using namespace std;
const int N=11;
int g[N][N];
int f[2*N][N][N]; // 假设有两个小朋友在同时从A走向B，g[k][i1][i2]=w,表示第一个小朋友
//走到第(i1,k-i1),第二个小朋友走到(i2,k-i2)时的最小值为w
int main(){
    int n;
    cin >> n;
    int a,b,c;
    while(cin>>a>>b>>c,a){
        g[a][b]=c;
    }
    for(int k=2;k<=2*n;k++){//从A走到B必然要走2*n-2次（曼哈顿距离）,k要从2开始因为一步没走时在（1，1）点
        for(int i1=1;i1<=n;i1++){
            for(int i2=1;i2<=n;i2++){
                int j1=k-i1,j2=k-i2;
                if(j1<=n&&j1>=1&&j2<=n&&j2>=1){
                    //我们惊奇的发现，两人可能同时到达同一格子，这时只取一次t就行了
                    //不可能出现1人走到了另一人已经走过的格子上这种情况
                    int &x=f[k][i1][i2];
                    int t = g[i1][j1];
                    if(i1!=i2) t += g[i2][j2];
                    x = max(x, f[k-1][i1-1][i2-1]+t);
                    x = max(x, f[k-1][i1-1][i2]+t);
                    x = max(x, f[k-1][i1][i2-1]+t);
                    x = max(x, f[k-1][i1][i2]+t);
                }
            }
        }
    }
    cout << f[2*n][n][n] << endl;
    return 0;
}

参考题解

友好城市

// not because they are easy,but because they are hard.
//本题更像一个思维题，先想暴力怎么做 然后去优化，发现规律如果北岸城市编号是递增的，那么
//在所有合法的答案中所有北岸城市对应的南岸城市的编号一定是递增的否则会出现交叉
#include<bits/stdc++.h>
#define x first
#define y second
const int N=5050;
using namespace std;
pair<int,int>h[N];
int f[N]; // f[i]=j 表示以第i个数为开始的最长上升子序列的长度为j
int n;
int main(){
    cin >> n;
    for(int i=1;i<=n;i++){
        cin >> h[i].x >> h[i].y;
        f[i]=1;
    }
    sort(h+1,h+n+1);
    int ans=0;
    for(int i=n;i>=1;i--){
        for(int j=i+1;j<=n;j++){
            if(h[i].y<h[j].y){
                f[i]=max(f[i],f[j]+1);
            }
            ans=max(ans,f[i]);
        }
    }
    cout << ans <<endl;
    return 0;
}

参考题解

最长公共上升子序列


//f[i][j]=k 表示 1~i  1~j 且以b[j]为结尾的最长上升公共子序列的长度为k
//状态转移:包含a[i] 则必须满足a[i]==b[j] 则f[i][j]=max(f[i-1][1~j-1]+1);
//不包含a[i]  f[i][j]=max(f[i][j],f[i-1][j]);
#include<bits/stdc++.h>
using namespace std;
const int N=3030;
int a[N],b[N];
int f[N][N];
int n;
int main(){
    cin >> n;
    for(int i=1;i<=n;i++) cin>>a[i];
    for(int j=1;j<=n;j++) cin>>b[j];
    for(int i=1;i<=n;i++){
        for(int j=1;j<=n;j++){
            f[i][j]=f[i-1][j];
            int maxv=1;
            if(a[i]==b[j]){
                
                for(int k=1;k<j;k++){
                    if(b[k]<b[j]){
                        maxv=max(maxv,f[i-1][k]+1);
                    }
                }
                  f[i][j]=max(f[i][j],maxv);
            }
          
        }
    }
    int ans=0;
    for(int i=1;i<=n;i++){
        ans=max(ans,f[n][i]);
    }
    cout << ans ;
    return 0;
}

参考题解

混合背包问题

//完全背包看成一类   ， 多重背包 01背包看成一类
#include<bits/stdc++.h>
using namespace std;
const int N=1010;
int n,m;
int f[N];
int main(){
    cin >> n >> m;
    for(int i=1;i<=n;i++){
        int a,b,c;  // -1 01   0wanquan
        cin >> a >> b >> c;
        if(c==0){
            for(int j=a;j<=m;j++){
                f[j]=max(f[j],f[j-a]+b);
            }
        }
        else {
            if(c==-1) c=1;
            for(int k=1;k<=c;k=k*2){
                for(int j=m;j>=a*k;j--){
                    f[j]=max(f[j],f[j-a*k]+b*k);
                }
                c-=k;
            }
            if(c){
                for(int j=m;j>=c*a;j--){
                    f[j]=max(f[j],f[j-a*c]+b*c);
                }
            }
        }
    }
    cout << f[m];
    return 0;
}

潜水员问题

// 背包问题求最值问题：求体积不超过v的最大值 f[i][j]=0;
//                     求体积恰好为v的最大值：f[0][0]=0,f[其他][其他]=-0x3f3f3f3f
//                                  的最小值:f[0][0]=0,f[其他][其他]=0x3f3f3f3f
//                     求体积至少为v的最小值(只会求最小 潜水员) f[0][0]=0,f[其他][其他]=0x3f3f3f3f
//背包问题求方案数的问题:求体积不超过v的方案数:f[0][i]=1;
//                       求体积恰好为v的方案数:f[0][0]=1;
//                       求体积至少为v的方案数:f[0][0]=1;
#include<bits/stdc++.h>
using namespace std;
const int N=1010;
int f[N][N]; // 体积至少为i和j的最小值为k
int v1,v2,n;
int a[N],b[N],c[N];
int main(){
    cin >> v1 >> v2 >> n;
    for(int i=1;i<=n;i++){
        cin >> a[i] >> b[i] >> c[i];
    }
    memset(f,0x3f,sizeof f);
    f[0][0]=0;
    for(int i=1;i<=n;i++){
        for(int j=v1;j>=0;j--){
            for(int k=v2;k>=0;k--){
                f[j][k]=min(f[j][k],f[max(0,j-a[i])][max(k-b[i],0)]+c[i]);
            }
        }
    }
    cout << f[v1][v2];
    return 0;
}

机械分配

//注意背包问题是怎么输出方案的
#include<bits/stdc++.h>
using namespace std;
const int N=20;
int g[N][N];
int f[N][N];
int n,m;
int main(){
    cin >> n >> m;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            cin >> g[i][j];
        }
    }
    for(int i=1;i<=n;i++){
        for(int j=0;j<=m;j++){
            for(int k=0;k<=j;k++){
                f[i][j]=max(f[i][j],f[i-1][j-k]+g[i][k]);
            }
        }
    }
    cout<<f[n][m]<<endl;
    for(int i=n;i>=1;i--){
        for(int j=0;j<=m;j++){
            if(f[i][m]==f[i-1][m-j]+g[i][j]){
                cout<< i <<" " << j <<endl;
                m-=j;
                break;
            }
        }
    }
    return 0;
}

有依赖的背包问题

//thread:f[N][N]=k  表示以i为根节点体积不超过j的最大价值为k
//状态转移：不选择第i个..
// 选择第i个 f[i][j]=max(f[i][j],f[i][j-k]+f[son][k]) 0<=j<=m-v[i],0<=k<=j-v[u]
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=1010;
int n,m;
int idx,h[N],e[N],ne[N],w[N],v[N];
//优化掉一维前:f[i][k][j] (k表示以i为根节点i一共有k个分叉即k个子树) 以i为根节点从前k个子树中选体积不超过j的最大值
int f[N][N];
void add(int a,int b){
    e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}
void dfs(int u){
    for(int i=v[u];i<=m;i++) f[u][i]=w[u];
    for(int i=h[u];i!=-1;i=ne[i]){
        int son=e[i];
        dfs(son);
        for(int j=m;j>=v[u];j--){//为什么要倒着枚举捏？因为要优化掉一维 优化掉哪一维捏？
            for(int k=0;j-k>=v[u];k++){ // 优化掉了第二维跟分组背包一样，详情请看小虎成员题解
                f[u][j]=max(f[u][j],f[u][j-k]+f[son][k]);
            }
        }
    }
 
}
int main(){
    cin >> n >> m;
    memset(h,-1,sizeof h);
    int st;
    for(int i=1;i<=n;i++){
        int a,b,c;
        cin >> a >> b >> c;
        v[i]=a,w[i]=b;
        if(c==-1) {
            st=i;
            continue;
        }
        add(c,i);
    }
    dfs(st);
    cout << f[st][m];
    return 0;
}

背包问题求具体方案数

//与普通求方案数不一样，本题是求最大体积不超过v ，且总价值最大的方案数，平常是求
// 体积不超过v的方案数， 本体不能想当然先求一遍01背包然后看f[i][j]是否等于f[n][m]
//如果等于则加一个答案，这样是错误的，会有重复，因为比如
// 16 200
// 17 200
// 18 200
// 19 200
// 20 200
//这几种方案是等价的,按照想当然，这几种方案会累加
// 还有一点 本题定义数组g的含义时 是恰好。为什么不定义成不超过？
//  因为定义成恰好 比较容易统计方案数 ，定义成不超过还要考虑到容斥
#include<bits/stdc++.h>
using namespace std;
const int N=1010;
int f[N][N]; // f[i][j] //表示从前i个物品中选其中体积恰好为j的最大价值
int g[N][N];// g[i][j] //表示从前i个物品中选，其中体积恰好为j的方案数
int n,m;
int v[N],w[N];
int mod=1e9+7;
int main(){
    cin >> n >> m;
    for(int i=1;i<=n;i++){
        cin >> v[i] >> w[i];
    }
    memset(f,-0x3f,sizeof f);
    f[0][0]=0;
    g[0][0]=1;
    int maxx=0;
    for(int i=1;i<=n;i++){
        for(int j=0;j<=m;j++){
            f[i][j]=f[i-1][j];
            if(j>=v[i]){
                f[i][j]=max(f[i-1][j],f[i-1][j-v[i]]+w[i]);
            }
            if(f[i][j]==f[i-1][j]){
                g[i][j]=(g[i][j]+g[i-1][j])%mod;//
            }
            if(f[i][j]==f[i-1][j-v[i]]+w[i]&&j>=v[i]){
                g[i][j]=(g[i][j]+g[i-1][j-v[i]])%mod;
            }
        }
    }
    // for(int i=1;i<=n;i++){
    //     for(int j=0;j<=m;j++){
    //         if(f[i][j]==f[i-1][j]){
    //             g[i][j]=(g[i][j]+g[i-1][j])%mod;//
    //         }
    //         if(f[i][j]==f[i-1][j-v[i]]+w[i]&&j>=v[i]){
    //             g[i][j]=(g[i][j]+g[i-1][j-v[i]])%mod;
    //         }
    //     }
    // }
    int tmp=0;;
    for(int i=1;i<=n;i++){
        for(int j=0;j<=m;j++){
            if(f[i][j]>tmp) tmp=f[i][j];
        }
    }
    int res=0;
    for(int j=0;j<=m;j++){
        if(tmp==f[n][j]){
            res=(res+g[n][j])%mod;
        }
    }
    cout << res;
    return 0;
}

小国王

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N=12,M=1<<11;
vector<int>state;
vector<int>st[M];
int n,m;
int cnt[M];
int f[N][110][M];
int num(int x){
    int sum=0;
    while(x){
        if(x&1){
            sum++;
        }
        x=x>>1;
    }
    return sum;
}
signed main(){
    int n,m;
    cin >> n >> m;
    for(int i=0;i< 1<<n;i++){  // 注意这里不可以随意取到等号，取到等号是不合法的，取到等号时，i的2进制长度为n+1位
        if(!(i&(i>>1))){
            state.push_back(i);
            cnt[i]=num(i);
        }
    }
    f[0][0][0]=1;
    for(int i=0;i<(int)state.size();i++){
        for(int j=0;j<(int)state.size();j++){
            int a=state[i],b=state[j];
            if(!(a&b) && !(a&(b>>1)) && !(a&(b<<1))){
                st[i].push_back(j);
            }
        }
    }
    for(int i=1;i<=n;i++){
        for(int j=0;j<=m;j++){
            for(int k=0;k<(int)state.size();k++){
                int a=cnt[state[k]];
                if(j<a) continue;
                for(int l=0;l<(int)st[k].size();l++){
                     f[i][j][k]+=f[i-1][j-a][  st[k][l] ];
                }
            }
        }
    }
    int res=0;
    for(int i=0;i<(int)state.size();i++){
      //  cout << f[n][m][state[i]] << endl;
        res+=f[n][m][i];//注意这里加的是f[n][m][i] 不是f[n][m][state[i]],因为我们
        //在dp的过程中 用的是编号代替的状态本身，所以累加的时候应该用编号
    }
    cout << res;
    return 0;
}
//比较容易理解的版本
#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N=12,M=1<<11;
vector<int>state;
vector<int>st[M];
int n,m;
int cnt[M];
int f[N][110][M];
int num(int x){
    int sum=0;
    while(x){
        if(x&1){
            sum++;
        }
        x=x>>1;
    }
    return sum;
}
signed main(){
    int n,m;
    cin >> n >> m;
    for(int i=0;i< 1<<n;i++){  // 注意这里不可以随意取到等号，取到等号是不合法的，取到等号时，i的2进制长度为n+1位
        if(!(i&(i>>1))){
            state.push_back(i);
            cnt[i]=num(i);
        }
    }
    f[0][0][0]=1;
    for(int i=0;i<(int)state.size();i++){
        for(int j=0;j<(int)state.size();j++){
            int a=state[i],b=state[j];
            if(!(a&b) && !(a&(b>>1)) && !(a&(b<<1))){
                st[a].push_back(b);//这里与上个代码的不同，上个代码存的是编号
                //这个存的是状态
                //上个代码 st[i][j]=k 表示第k个状态在所有可以转移到第i个状态中排第j个可以转移到第i个状态的
                //这个是st[i][j]=k 表示k状态排第j个可以转移到i状态
            }
        }
    }
    for(int i=1;i<=n;i++){
        for(int j=0;j<=m;j++){
            for(int k=0;k<(int)state.size();k++){
                int a=cnt[state[k]];//这里不同
                if(j<a) continue;
                for(int l=0;l<(int)st[state[k]].size();l++){//这里也不同
                     f[i][j][state[k]]+=f[i-1][j-a][  st[state[k]][l] ];//这里不同
                }
            }
        }
    }
    int res=0;
    for(int i=0;i<(int)state.size();i++){
      //  cout << f[n][m][state[i]] << endl;
        res+=f[n][m][state[i]];//这里不同 state[i]=k   i是编号 k才是状态
    }
    cout << res;
    return 0;
}

选元素

//f[i][j]=k 表示从前i个数中选 且包含第i个数 当前已经选了j个数的最大值
//那么 第j-1个数 也就是倒数第二个数的下标t应该满足   i-k<=t<i
//状态转移  f[i][j]=max(f[i][j],f[t][j-1]+a[i]) (i-k<=t<i) 
//答案就应该是 res=max(res,f[i][x])  1=<i<=n
#include<iostream>
#include<cstring>
#define int long long
using namespace std;
const int N=220;
int n,k,x;
int f[N][N];
int a[N];
signed main(){
    cin >> n >> k >> x;
    
    for(int i=1;i<=n;i++) cin>>a[i];
    memset(f,-0x3f,sizeof f);
    f[0][0]=0;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=x;j++){
            for(int t=i-k;t<i;t++){
                if(t>=0) f[i][j]=max(f[i][j],f[t][j-1]+a[i]);
            }
        }
    }
    int res=-1;
    for(int i=n-k+1;i<=n;i++){  // 因为i从n-k+1开始算才能满足选的x可以覆盖到整个区间
        res=max(res,f[i][x]);
    }
    cout << res;
    return 0;
}

能量项链

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;

const int N=210,INF=0x3f3f3f3f;

int n;
int a[N];
int g[N][N];

int main()
{
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        cin>>a[i];
        a[i+n]=a[i];
    }
    memset(g,-0x3f,sizeof g);
    for(int len=1;len<=n;len++)
        for(int i=1;i+len-1<=n*2;i++)
        {
            int l=i,r=i+len-1;
            if(len==1)  g[l][r]=0;
            else for(int k=l;k<r;k++)    g[l][r]=max(g[l][r],g[l][k]+g[k+1][r]+a[l]*a[k+1]*a[r+1]);
            //这里的过程同石子合并，这里不难想到若将l到k的珠子合并之后会变成一个首是l而尾k+1的珠子；
            //同理若将k+1到r的珠子合并之后会变成一个首是k+1而尾r+1的珠子；
            //g[l][l]+g[l+1][r]+a[l]*a[l+1]*a[r+1] 可以理解为先把l+1到r合并然后在和l合并
        }
    int maxv=-INF;
    for(int i=1;i<=n;i++)
        maxv=max(g[i][i+n-1],maxv);//区间长度为n
    cout<< maxv <<endl;
    return 0;
}

加分二叉树

#include<bits/stdc++.h>
using namespace std;
const int N=35;
int f[N][N];//f[i][j]=k表示i~j的最大值为k
int g[N][N]; //g[i][j]=k  表示i~j中间的根节点为k
int n;
int w[N];
void path(int l,int r){
    if(l>r){
        return;
    }
    cout << g[l][r]<<" ";
    path(l,g[l][r]-1);
    path(g[l][r]+1,r);
}
int main(){
    cin >> n;
    for(int i=1;i<=n;i++){
        cin >> w[i];
        g[i][i]=i;  // 初始化
        f[i][i]=w[i];
    }
    for(int len=2;len<=n;len++){
        for(int l=1;l+len-1<=n;l++){
            int r=l+len-1;
            for(int k=l;k<=r;k++){
                int left,right;
                if(k==l){ //说明左子树为空
                    left=1;
                }
                else {
                    left=f[l][k-1];
                }
                if(r==k){  //说明右子树为空
                    right=1;
                }
                else {
                    right=f[k+1][r];
                }
                if(left*right+w[k]>f[l][r]){
                    f[l][r]=left*right+w[k];
                    g[l][r]=k;
                }
        }}
    }
    cout << f[1][n]<<endl;
    path(1,n);
    return 0;
}

树的最长路径

#include<iostream>
#include<cstring>
using namespace std;
const int N=10010;
int h[N*2],w[N*2],ne[N*2],idx,e[N*2];
void add(int a,int b,int c){
    e[idx]=b,ne[idx]=h[a],w[idx]=c,h[a]=idx++;
}
int n;
int f[N];
int dfs(int u,int father){ // 每次返回最长值
    int max1=0,max2=0;
    for(int i=h[u];i!=-1;i=ne[i]){
        int j=e[i]; // i 是idx
        //if(j==u) continue;判断是否是父节点不是这样判断的，你这个u是当前节点往其他方向延申的
        //这个j就不可能是u，j是从u发出到达的一个点，u怎么可能发出一个到达它自己的东西呢？
        if(j==father) continue;
        int tmp=dfs(j,u)+w[i];
      //  cout << tmp << endl;
        if(tmp>=max1){
            max2=max1;
            max1=tmp;
        }
        else if(tmp>max2){
            max2=tmp;
        }
    }
    f[u]=max1+max2;
    return max1;
}
int main(){
    memset(h,-1,sizeof h);
    cin >> n;
    for(int i=1;i<=n-1;i++){
        int a,b,c;
        cin >> a >> b >> c;
        add(a,b,c);
        add(b,a,c);
    }
    int res=0;
    dfs(1,-1);
    for(int i=1;i<=n;i++){
        res=max(res,f[i]);
    }
    cout << res;
    return 0;
}

树的中心

按照自己的理解写的 确实是比较麻烦
#include<iostream>
#include<cstring>
using namespace std;
const int N=10010;
int h[N*2],w[N*2],ne[N*2],idx,e[N*2];
void add(int a,int b,int c){
    e[idx]=b,ne[idx]=h[a],w[idx]=c,h[a]=idx++;
}
int n;
int f[N];
int max1[N],max2[N],up[N];
int num[N]; //num[i]=j 就表示第i个点的最长路径的下一个点是j
int dfs(int u,int father){ // 每次返回最长值
    for(int i=h[u];i!=-1;i=ne[i]){
        int j=e[i]; // i 是idx
        if(j==father) continue;
        int tmp=dfs(j,u)+w[i];
      //  cout << tmp << endl;
        if(tmp>=max1[u]){
            max2[u]=max1[u];
            max1[u]=tmp;
            num[u]=j;
        }
        else if(tmp>max2[u]){
            max2[u]=tmp;
        }
    }
    //f[u]=max1+max2;
    return max1[u];
}
//先要更新父节点的真实长度
void dfs2(int u,int father){
    for(int i=h[u];i!=-1;i=ne[i]){
        int j=e[i];//ishi idx
        if(j==father) continue;
        if(num[u]==j){ // u的最长路径经过子节点j了
            //max1[j]=max(max1[j],max2[u]+w[i]);
            //看一下能否更新j节点的最长路径和次长路径
            if(max2[u]+w[i]>max1[j]){
                max2[j]=max1[j];
                max1[j]=max2[u]+w[i];
                num[j]=u;
            }
            else if(max2[u]+w[i]>max2[j]){
                max2[j]=max2[u]+w[i];
            }
        }
        else {
            //max1[j]=max(max1[j],max1[u]+w[i]);
            //如果说最长路径被不经过j的路径更新的话 那么最长路径
            //也就不再经过j的子节点了
            if(max1[u]+w[i]>max1[j]){
                max2[j]=max1[j];
                max1[j]=max1[u]+w[i];
                num[j]=u;
            }
            else if(max1[u]+w[i]>max2[j]){
                max2[j]=max1[u]+w[i];
            }
        }
        dfs2(j,u);
    }
}
int main(){
    memset(h,-1,sizeof h);
    cin >> n;
    for(int i=1;i<=n-1;i++){
        int a,b,c;
        cin >> a >> b >> c;
        add(a,b,c);
        add(b,a,c);
    }
    int res=0x3f3f3f3f;
    dfs(1,-1);
    dfs2(1,-1);
    for(int i=1;i<=n;i++){
        res=min(res,max1[i]);
    }
    cout << res;
    return 0;
}

y总代码
#include<bits/stdc++.h>
using namespace std;
const int N=1e4+10;
int n;
int h[N],w[N*2],e[N*2],ne[N*2],idx;
int dn1[N],dn2[N],up[N],son1[N],son2[N];
void add(int a,int b,int c){
    e[idx]=b,ne[idx]=h[a],w[idx]=c,h[a]=idx++;
}
void dfs_down(int u,int father){
    for(int i=h[u];~i;i=ne[i]){
        int j=e[i];
        if(j==father) continue;
        dfs_down(j,u);//这里的dp要求子节点先被算出来
        if(w[i]+dn1[j]>=dn1[u]){
            dn2[u]=dn1[u];
            dn1[u]=w[i]+dn1[j];
            son2[u]=son1[u];
            son1[u]=j;
        }
        else if(w[i]+dn1[j]>dn2[u]){
            dn2[u]=w[i]+dn1[j];
            son2[u]=j;
        }
    }
    return;
}
void dfs_up(int u,int father){
    for(int i=h[u];~i;i=ne[i]){
        int j=e[i];
        if(j==father) continue;
        if(j==son1[u]){  //如果说d1[u]经过他的子节点j
            up[j]=max(up[u]+w[i],dn2[u]+w[i]);
        }
        else {
            up[j]=max(up[u]+w[i],dn1[u]+w[i]);
        }
        dfs_up(j,u); // 这里的dp要求父节点先被算出来
    }
    return;
}
int main(){
    memset(h, -1, sizeof h); //不要忘了邻接表初始化！
    cin >> n;
    for(int i=0;i<n-1;i++){
        int a,b,c;
        cin >> a >> b >> c;
        add(a,b,c),add(b,a,c);
    }
    dfs_down(1,-1);
    dfs_up(1,-1);
    int ans=0x3f3f3f3f;
    for(int i=1;i<=n;i++){
        ans=min(ans,max(up[i],dn1[i]));
    }
    cout << ans;
    return 0;
}

数星星

//细节很多，本题利用了欧几里得距离来记录哈希值，就是对于一个图形无论怎么变化
//对称或者翻转它的总体欧几里得距离是不变的（欧几里得总距离可以通过图形中任意两个点求欧几里得距离累加得到），可以利用这一性质进性hash
#include<bits/stdc++.h>
#define x first
#define y second
using namespace std;
const int N=110;
typedef pair<int,int>PII;
PII q[N*N]; //为什么要开N*N 因为 n*m的矩阵 至多有这么多个点
int dx[8]={-1,0,1,-1,1,-1,0,1},dy[8]={1,1,1,0,0,-1,-1,-1};
char g[N][N];
int n,m,num;
void bfs(int a, int b)
{
    q[num ++ ] = {a, b};
    g[a][b] = '0';
    queue<PII>p;
    p.push({a,b});
    while(p.size()){
        auto t=p.front();
        p.pop();
        for(int i=0;i<8;i++){
            int X=t.x+dx[i],Y=t.y+dy[i];
            if(X>=0&&X<n&&Y>=0&&Y<m&&g[X][Y]=='1'){
                q[num++]={X,Y};
                g[X][Y]='0';
                p.push({X,Y});
            }
        }
    }
}
double get_dist(PII a,PII b){
    return sqrt((b.y-a.y)*(b.y-a.y)+(b.x-a.x)*(b.x-a.x));
}
double get_hash(){
    double res=0;
    for(int i=0;i<num;i++){
        for(int j=i+1;j<num;j++){
            res+=get_dist(q[i],q[j]);
        }
    }
    return res;
}
char get_id(double key){
    static double hash[30];
    static int id=0;
    for(int i=0;i<id;i++){
        if(fabs(key-hash[i])<1e-8){ // 求绝对值
            return i+'a';
        }
    }
    hash[id++]=key;
    return id-1+'a';
}
int main(){
    cin >> m >> n;
    for(int i=0;i<n;i++) cin>>g[i];
    for(int i=0;i<n;i++){
        for(int j=0;j<m;j++){
            if(g[i][j]=='1'){
                num=0;
                bfs(i,j);
                char f=get_id(get_hash());
                for(int k=0;k<num;k++){
                    g[q[k].x][q[k].y] = f;
                }
            }
            
        }
    }
    for(int i=0;i<n;i++) cout << g[i] << endl;
    return 0;
}

牛的学术圈II

//思维题
//假设g[a][b]=1 表示Ca>Cb 则 Ea<Eb
//证明 Ea>Eb g[b][a]=1&&g[a][b]!=1   即1
//证明 Ea<Eb g[a][b]=1&&g[b][a]!=1   即0
//证明是 ？  g[a][b]==0&&g[b][a]==0; 即?
#include<iostream>
#include<cstring>
#include<unordered_map>
using namespace std;
const int N=220;
unordered_map<string,int>id;
int g[N][N];//g[i][j]=1 表示Ca>Cb 则 Ea<Eb
int n,m;
int main(){
    cin >> m >> n;
    for(int i=0;i<n;i++){
        string tmp;
        cin >> tmp;
        id[tmp]=i;
    }
    string name[N];
    while(m--){
        for(int i=0;i<n;i++) cin>>name[i];
        for(int i=0;i<n;i++){
            int j=i+1;
            while(j<n&&name[j]>name[j-1]) j++;
            while(j<n){
                int a=id[name[i]],b=id[name[j]];
                g[a][b]=1;
                j++;
            }
        }
    }
    for(int i=0;i<n;i++){
        for(int j=0;j<n;j++){
            if(i==j) cout << "B";
            else if(g[i][j]==0&&g[j][i]==0) cout <<"?";
            else if(g[j][i]=1&&g[i][j]!=1) cout<<1;
            else cout <<0;
        }
        cout << endl;
    }
    return 0;
}

本质上升序列

#include <iostream>

using namespace std;
const int N = 1000;

int f[N];
string ss;

int main()
{
	ss = "tocyjkdzcieoiodfpbgcncsrjbhmugdnojjddhllnofawllbhfiadgdcdjstemphmnjihecoapdjjrprrqnhgccevdarufmliqijgihhfgdcmxvicfauachlifhafpdccfseflcdgjncadfclvfmadvrnaaahahndsikzssoywakgnfjjaihtniptwoulxbaeqkqhfwl";

	for(int i = 0; i < ss.size(); i ++ )
	{
		f[i] = 1;
		for(int j = 0; j < i;j ++ )
		{
			if(ss[i] > ss[j]) f[i] += f[j];
			if(ss[i] == ss[j]) f[i] -= f[j];
		}
	}
	
	long long res = 0;
	for(int i = 0; i < ss.size(); i ++ ) res += f[i]; 
	cout << res << endl;
	return 0;
}

参考题解

究极无敌暴龙战神
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【南卡樱桃|读书笔记《学习高手》】
weixin_44698581的博客
04-21 9278
∝学霸分享 6大课 通过英语、写作和SMART原则、OKR工作法、LEO解读五步法等文章。同样适用于国内教育环境。 ∝3 学霸分享，直通世界名校的超级学习法 ∞第18课 LEO手把手教你如何学好英语 ◆第1小课 单词 ◆第2小课 语法 ◆第3小课 听力 ◆第4小课 阅读 ◆第5小课 口语 LEO的学习仪式感 我在不同英语学习阶段使用的教材 ∞第19课 三要素写作法，把文章写到读者心里去 ◆第1小课 Ethos，可信 ◆第2小课 Pathos，情感 ◆第3小课 Logos，逻辑 ◆19-本课核心方法回顾 ∞第
解答PCB设计技巧疑难解析（二）
01-19
10、关于test coupon。 　test coupon 是用来以TDR (Time Domain Reflectometer) 测量所生产的PCB 板的特性阻抗是否满足设计需求。一般要控制的阻抗有单根线和差分对两种情况。所以， test coupon 上的走线线宽和线...
重庆邮电大学计算机学硕第四名（802）考研经验贴
梦想终会实现
02-24 7798
2023届重庆邮电大学计算机学硕初试374分经验贴
转载《2020年校招面经心得》
专注于C/C++/Linux领域创作
10-28 1540
原文链接：https://blog.csdn.net/ZY...
《极简学习法》读书笔记
每个人都是独一无二的，把握好自己的节奏，跟着自己的心走。
09-30 1063
书名：《极简学习法》标签：清北学霸经历 学会学习 极简学习 刻意练习极简三阶段：精准输入（摄入），深度消化（消化），多元输出（实际应用）。学习本质：输入 消化 输出让孩子产生变化：确立理想，规划实现理想的路径，将该路径与学习联系。将知识点学透彻再做题。大事物不断拆解小事物，难得事情分解成一个个简单的小事情往往就会迎刃而解。学习倒推思维：学直接决定结果的知识。学习应当是有计划性的，不要盲目，需要在有问题的地方逐一突破盯紧目标是推倒思维的关键（无需太在意其他人）。
电脑入门与提高疑难排解大全
04-06
《电脑入门与提高疑难排解大全》内容主要包括操作系统疑难排解、常用工具软件疑难排解、注册表疑难排解、BIOS疑难排解、文字办公疑难排解、病毒与安全防范疑难排解、网络应用疑难排解等七个部分，集实用性、资料性、...
疑难问题典型题.pdf
09-18
疑难问题典型题.pdf
PPP二十个疑难解答.pdf
10-14
PPP二十个疑难解答.pdf
PCB技术中的解答PCB设计技巧疑难解析（二）
11-04
10、关于test coupon。 　test coupon 是用来以TDR (Time Domain Reflectometer) 测量所生产的PCB 板的特性阻抗是否满足设计需求。一般要控制的阻抗有单根线和差分对两种情况。所以， test coupon 上的走线线宽和线...
算法014：找到字符串中所有字母异位词
m0_62319039的博客
07-14 440
算法014：找到字符串中所有字母异位词
LC53最大子数组和、lc5最长回文子串、lc283移动零
m0_47536537的博客
07-14 207
请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。连续子数组 [4,-1,2,1] 的和最大，为 6。移动到数组的末尾，同时保持非零元素的相对顺序。，必须在不复制数组的情况下原地对数组进行操作。"aba" 同样是符合题意的答案。是数组中的一个连续部分。，编写一个函数将所有。LC53最大子数组和。
代码随想录算法训练营第三十二天
weixin_44791877的博客
07-14 220
这道题自己思考ac出来了，主要是这道题需要使用二维的dp数组进行规划，由于动归是递推的，所以从结果向前思考，因此到右下角的方法只能由右下角这个格子或者左边这个格子走过来，因此右下角这个格子的方法数应该等于上一个格子的方法数加上左边这个格子的方法数。值得注意的是只有一行的或者一列的每个格子都只有1种方法，还有就是多行多列的边界格子也是只有一种方法，这个也是要初始化的。然后初始化边界的时候在障碍物之前的都初始化为1，障碍物以及障碍物之后的都初始化为0；首先几个特殊情况 当障碍物在起点或者终点的话直接返回0；
树与二叉树
最新发布
2201_76027754的博客
07-15 767
树和二叉树
摩尔投票算法
qq_55846232的博客
07-14 465
摩尔投票算法的介绍以及相关例题的讲解
手撕七大排序(三)
Zbldx的博客
07-14 307
手撕七大排序 （三）
【JavaScript 算法】哈希表：快速查找与存储
Allen-
07-15 773
哈希表（Hash Table）是一种非常高效的数据结构，用于实现快速的查找和存储操作。通过使用哈希函数将数据映射到数组中的某个位置，哈希表能够在常数时间内完成插入、删除和查找操作。
【C++】B3716分解质因子3 题解_素数筛法_欧拉筛+埃氏筛_算法竞赛
YLCHUP的博客
07-14 698
洛谷B3716题解，一道巧妙的质数筛法变形题，讲解得很详细，适合中等水平学习。快来看ヾ(•ω•`)o
【算法/序列】等差数列&&子序列&&算术序列&&最长对称子串
island1314的博客
07-14 909
子序列：是通过从原序列删除零个或多个元素并在不改变顺序的情况下排列其余元素而获得的序列。：是通过从原序列删除零个或多个元素并在不改变顺序的情况下排列其余元素而获得的序列。该题主要是求其满足等差性质的子数组个数，并且子数组在原数组的相对顺序不能变，并且。长度为3的子序列：（1，2，3）、（1，2，5）、（1，4，5）长度为1的子序列：（1）、（2）、（3）、（4）、（5）长度为2的子序列：长度为2的子序列都是算术子序列。：是数组中的一个连续序列。长度为4的子序列：0。长度为5的子序列：0。
计算机二级Python100道疑难问题
12-07
引用提到了历年来计算机二级python真题题库，共15套真题，80道习题及2套练习题，而引用提到了全国计算机等级考试新增了“Python 语言程序设计”科目。但是，这些信息并没有提供关于计算机二级Python100道疑难问题的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值