【jzoj4827】【钻石游戏】

题目大意

一个M行N列的棋盘,里面放了M*N个各种颜色的钻石。每一次你可以选择任意两个相邻的颜色不同的钻石,进行交换。两个格子相邻的定义是两个格子有一条公共边。每次交换的分值为通过这次交换后能够形成的最大矩形的面积,具体请见样例。跟传统的钻石游戏不太一样的是,交换后钻石不会消除。现在告诉你每一次操作,请输出每一次所能得到的分值。

解题思路

首先我们可以预处理出一个点往上下左右最远扩展到哪里(同色),每个询问就从两个点中间的连接线o(n)往左往右扩展,求出答案。

code

#include<set>
#include<cmath>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define LD double
#define LL long long
#define max(a,b) ((a>b)?a:b)
#define min(a,b) ((a>b)?b:a)
#define fo(i,j,k) for(int i=j;i<=k;i++)
#define fd(i,j,k) for(int i=j;i>=k;i--)
using namespace std;
int const inf=2147483647;
int const maxn=500,maxm=500;
int n,m,p,a[maxm+10][maxn+10],f[maxm+10][maxn+10],ff[maxm+10][maxn+10],g[maxm+10][maxn+10],
gg[maxm+10][maxn+10],b[maxn+10],s[maxn+10],c[maxn+10];
int get(int p){
    int ans=1;
    /*c[0]=0;
    fo(i,1,b[0]){
        int tmp=0;
        for(;c[0]&&(c[c[0]]>=b[i]);tmp+=s[c[0]],c[0]--);
        c[++c[0]]=b[i];s[c[0]]=tmp+1;
        if((i>=p)&&(i-s[c[0]]+1<=p))ans=max(ans,s[c[0]]*c[c[0]]);
    }*/
    int l=p,r=p,mi=b[p];
    for(;(l!=1)||(r!=b[0]);){
        ans=max(ans,mi*(r-l+1));
        if((l!=1)&&(r!=b[0])){
            if(b[l-1]>b[r+1]){
                mi=min(mi,b[l-1]);
                l--;
            }else{
                mi=min(mi,b[r+1]);
                r++;
            }
        }else if(l!=1){
            mi=min(mi,b[l-1]);
            l--;
        }else{
            mi=min(mi,b[r+1]);
            r++;
        }
    }
    return max(ans,mi*(r-l+1));
}
int main(){
    //freopen("diamond.in","r",stdin);
    //freopen("diamond.out","w",stdout);
    freopen("d.in","r",stdin);
    freopen("d.out","w",stdout);
    scanf("%d%d",&m,&n);
    fo(i,1,m)
        fo(j,1,n){
            scanf("%d",&a[i][j]);
            if(a[i][j]==a[i][j-1])f[i][j]=f[i][j-1]+1;
            else f[i][j]=1;
            if(a[i][j]==a[i-1][j])g[i][j]=g[i-1][j]+1;
            else g[i][j]=1;
        }
    fd(i,m,1)
        fd(j,n,1){
            if(a[i][j]==a[i][j+1])ff[i][j]=ff[i][j+1]+1;
            else ff[i][j]=1;
            if(a[i][j]==a[i+1][j])gg[i][j]=gg[i+1][j]+1;
            else gg[i][j]=1;
        }
    scanf("%d",&p);
    fo(i,1,p){
        int x,y,xx,yy;scanf("%d%d%d%d",&x,&y,&xx,&yy);
        if(x>xx)swap(x,xx);
        if(y>yy)swap(y,yy);
        swap(a[x][y],a[xx][yy]);
        fo(j,1,n)
            if(a[x][j]==a[x][j-1])f[x][j]=f[x][j-1]+1;
            else f[x][j]=1;
        fo(j,1,n)
            if(a[xx][j]==a[xx][j-1])f[xx][j]=f[xx][j-1]+1;
            else f[xx][j]=1;
        fd(j,n,1)
            if(a[x][j]==a[x][j+1])ff[x][j]=ff[x][j+1]+1;
            else ff[x][j]=1;
        fd(j,n,1)
            if(a[xx][j]==a[xx][j+1])ff[xx][j]=ff[xx][j+1]+1;
            else ff[xx][j]=1;
        fo(j,1,m)
            if(a[j][y]==a[j-1][y])g[j][y]=g[j-1][y]+1;
            else g[j][y]=1;
        fo(j,1,m)
            if(a[j][yy]==a[j-1][yy])g[j][yy]=g[j-1][yy]+1;
            else g[j][yy]=1;
        fd(j,m,1)
            if(a[j][y]==a[j+1][y])gg[j][y]=gg[j+1][y]+1;
            else gg[j][y]=1;
        fd(j,m,1)
            if(a[j][yy]==a[j+1][yy])gg[j][yy]=gg[j+1][yy]+1;
            else gg[j][yy]=1;
        int ans=1;
        if(x==xx){
            int l=x,r=x;
            for(;(a[l-1][y]==a[x][y]);l--);
            for(;(a[r+1][y]==a[x][y]);r++);
            b[0]=0;fo(j,l,r)b[++b[0]]=f[j][y];
            ans=get(x-l+1);
            l=x,r=x;
            for(;(a[l-1][yy]==a[xx][yy]);l--);
            for(;(a[r+1][yy]==a[xx][yy]);r++);
            b[0]=0;fo(j,l,r)b[++b[0]]=ff[j][yy];
            ans=max(ans,get(x-l+1));
        }else{
            int l=y,r=y;
            for(;(a[x][l-1]==a[x][y]);l--);
            for(;(a[x][r+1]==a[x][y]);r++);
            b[0]=0;fo(j,l,r)b[++b[0]]=g[x][j];
            ans=get(y-l+1);
            l=y,r=y;
            for(;(a[xx][l-1]==a[xx][yy]);l--);
            for(;(a[xx][r+1]==a[xx][yy]);r++);
            b[0]=0;fo(j,l,r)b[++b[0]]=gg[xx][j];
            ans=max(ans,get(y-l+1));
        }
        printf("%d\n",ans);
    }
    return 0;
}
### 解题思路 题目要求解决的是一个与图相关的最小覆盖问题,通常在特定条件下可以通过状态压缩动态规划(State Compression Dynamic Programming, SCDP)来高效求解。由于状态压缩的适用条件是状态维度较小(例如K≤10),因此可以利用二进制表示状态集合,从而优化计算过程。 #### 1. 状态表示 - 使用一个整数 `mask` 表示当前选择的点集,其中第 `i` 位为 `1` 表示第 `i` 个节点被选中。 - 定义 `dp[mask]` 表示在选中 `mask` 所代表的点集后,能够覆盖的节点集合。 - 可以通过预处理每个点的邻域信息(包括自身和所有直接连接的点),快速更新状态。 #### 2. 预处理邻域 对于每个节点 `u`,预先计算其邻域范围 `neighbor[u]`,即从该节点出发一步能到达的所有节点集合。这样,在后续的状态转移过程中,可以直接使用这些信息进行合并操作。 #### 3. 状态转移 - 初始化:对每个单独节点 `u`,设置初始状态 `dp[1 << u] = neighbor[u]`。 - 转移规则:对于任意两个状态 `mask1` 和 `mask2`,如果它们没有交集,则可以通过合并这两个状态得到新的状态 `mask = mask1 | mask2`,并更新对应的覆盖范围为 `dp[mask1] ∪ dp[mask2]`。 - 在所有状态生成之后,检查是否某个状态的覆盖范围等于全集(即覆盖了所有节点)。如果是,则记录此时使用的最少节点数量。 #### 4. 最优解提取 遍历所有可能的状态,找出能够覆盖整个图的最小节点数目。 --- ### 时间复杂度分析 - 状态总数为 $ O(2^K) $,其中 `K` 是关键点的数量。 - 每次状态转移需要枚举所有可能的子集组合,复杂度为 $ O(2^K \cdot K^2) $。 - 整体时间复杂度控制在可接受范围内,适用于 `K ≤ 10~20` 的情况。 --- ### 代码实现(状态压缩 DP) ```cpp #include <bits/stdc++.h> using namespace std; const int MAXN = 25; int neighbor[MAXN]; // 每个节点的邻域 int dp[1 << 20]; // dp[mask] 表示选中的点集合为 mask 时所能覆盖的点集合 int min_nodes; // 最小覆盖点数 void solve(int n, vector<vector<int>>& graph) { // 预处理每个节点的邻域 for (int i = 0; i < n; ++i) { neighbor[i] = (1 << i); // 包括自己 for (int j : graph[i]) { neighbor[i] |= (1 << j); } } // 初始化 dp 数组 memset(dp, 0x3f, sizeof(dp)); for (int i = 0; i < n; ++i) { dp[1 << i] = neighbor[i]; } // 状态转移 for (int mask = 1; mask < (1 << n); ++mask) { if (__builtin_popcount(mask) >= min_nodes) continue; // 剪枝 for (int sub = mask & (mask - 1); sub; sub = (sub - 1) & mask) { int comp = mask ^ sub; if (comp == 0) continue; int new_mask = mask; int covered = dp[sub] | dp[comp]; if (covered == (1 << n) - 1) { min_nodes = min(min_nodes, __builtin_popcount(new_mask)); } dp[new_mask] = min(dp[new_mask], covered); } } } int main() { int n, m; cin >> n >> m; vector<vector<int>> graph(n); for (int i = 0; i < m; ++i) { int u, v; cin >> u >> v; graph[u].push_back(v); graph[v].push_back(u); // 无向图 } min_nodes = n; solve(n, graph); cout << "Minimum nodes required: " << min_nodes << endl; return 0; } ``` --- ### 优化策略 - **剪枝**:当当前状态所用节点数已经超过已知最优解时,跳过后续计算。 - **提前终止**:一旦发现某个状态覆盖了全部节点,并且节点数达到理论下限,即可提前结束程序。 - **空间优化**:可以仅保存当前轮次的状态,减少内存占用。 --- ### 总结 本题通过状态压缩动态规划的方法,将原本指数级复杂度的问题压缩到可接受范围内。结合位运算技巧和预处理机制,能够高效地完成状态转移和覆盖判断操作。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值