原題鏈接https://www.luogu.org/problemnew/show/P2258

高中學長lwy給我們講了下這道難題。

其實這道題的思路很簡單：暴力枚舉每種行和列的排列情況，求出最小的分數；顯然這道藍題是不會這么輕易讓你AC的，好像只能得60分，所以我們考慮加上DP做法；

做法的結構大致是這樣的：首先枚舉其行的排列情況（類似全排列，只是元素個數確定），然后，對于每一種行的排列情況，DP出它列的最優情況，然后取所有行的排列情況的最優情況的最小值。

這樣的話時間復雜度會大大降低的。

代碼實現

我們先開幾個數組：

a [ i ][ j ]：矩陣第 i 行第 j 列的數；

dp [ i ][ j ]：枚舉列要用，表示前 i 列我們已經選了 j 列所得到的最小分值，注意要選第 i 列（這 j 列中包含第 i 列）；

ver [ i ]：第 i 列上下絕對值差的和；

del [ i ][ j ]：第 i 列和第 j 列左右絕對值差的和；

hang [ i ]：枚舉的子矩陣的第 i 行在原大矩陣的行數；

大體代碼思路：

我們先一遍dfs，找出行的全排列，當我們找夠了 r 行的時候，我們去再去找所有的 c 列，然后我們一遍DP求出當前行情況的最小分值，然后接著回到 dfs 找其他的行排列，直到找出所有的行排列為止；

先看一下 dfs 的代碼吧，處理的是找行的全排列的過程：

void dfs(int now, int pos)        //我們當前正在選第now行,這一行在原矩陣中是第pos行 
{
    if (now == r + 1)             //如果超出了r行,說明我們已經選完了r行,開始進行dp操作 
    {
        Dp();
        return;
    }
    if (pos == n + 1)             //判斷是否在原矩陣范圍內 
        return;
    for (int i = pos; i <= n; i++)//從第pos行開始往后選 
        hang[now] = i, dfs(now + 1, i + 1);  //繼續往下選 
//hang[now]=i :在子矩陣里的第now行就是原矩陣的第i行 
}

dfs 的過程應該不難理解，接下來就是最重要的 dp 過程了！

我們在用 dp 求當前行排列的最小分值之前，我們還要有一步預處理操作，就是將ver，del 數組先處理出來；

預處理ver，del 數組

這個其實很好實現，我們只要嚴格套上面這兩個數組的定義就好啦。

先看ver 數組怎么弄，我們回過頭來看這個數組的定義：

ver [ i ]：第 i 列上下絕對值差的和；

你看，我們現在把其中一種行排列給確定下來了，接下來要做的就是枚舉每一列，然后我們再枚舉子矩陣的每一行，套定義用下一行的值減去上一行的值再取絕對值就好啦（這里的行都是指的子矩陣），注意求和：

    for (int i = 1; i <= m; i++)                //枚舉每一列
        for (int j = 2; j <= r; j++)            //枚舉子矩陣的每一行 
            ver[i] += abs(a[hang[j]][i] - a[hang[j - 1]][i]) ;   //利用hang數組回到原矩陣去尋找值 

再看一下del數組怎么弄，我們再回過頭來看這個數組的定義：

del [ i ][ j ]：第 i 列和第 j 列左右絕對值差的和；

你會發現這個好像跟處理 ver 數組的方法差不多嘛：先枚舉每一列 i，然后再來一層枚舉列 k，不過這時候 k > i（因為我們要做左右差的絕對值和），然后枚舉子矩陣的每一行，第 k 列的值減去第 i 列的值再取絕對值就好啦：

    for (int i = 1; i <= m; i++)                //枚舉每一列 i 
        for (int k = i + 1; k <= m; k++)        //再找 i 之后的列 
            for (int j = 1; j <= r; j++)        //枚舉子矩陣的每一行 
                del[i][k] += abs(a[hang[j]][k] - a[hang[j]][i]); //套定義求出del數組

炒雞重要的dp

我們先看我們 dp 時要用到的 dp 數組的定義（萬物先看定義再思考方法嘛）：

dp [ i ][ j ]：枚舉列要用，表示前 i 列我們已經選了 j 列所得到的最小分值，注意要選第 i 列（這 j 列中包含第 i 列）；

考慮到我們已經得到了行的一種排列（行排列已確定），所以我們 dp 過程主要考慮怎么選列；

第一層大循環一定是枚舉所有的列，含義是：我們一共找了 i 列；

考慮到我們始終沒有涉及到子矩陣要有 c 列，所以在 dp 的時候我們要注意只選 c 列！

那么第二層循環也就出來了：我們枚舉1~c，表示在前 i 列（第一層循環的變量）中我們已經選上了 j 列；

第三層循環不是很好想，由于我們選的這個子矩陣的行和列不一定在原矩陣是連續的，所以作為已經被選上的第 i 列作為子矩陣的其中一列，我們并不知道子矩陣的上一列在原矩陣中的位置是否和 i 是相鄰的，所以我們有必要來枚舉這個距離，由此可以得出第三層循環：我們枚舉 k，表示在我們選擇第 i 列作為子矩陣的其中一列時，第 i - k 列也同樣被選作為子矩陣的其中一列，且這兩列在子矩陣中是相鄰的，由此我們就可以得出來狀態轉移方程了（艱辛啊）：

dp[i][j] = min(dp[i][j], dp[i - k][j - 1] + ver[i] + del[i - k][i]);
//第 i-k 列是第 i 列的上一列,所以應該要選擇j-1列
//加上新選的第 i 列的貢獻：第i列的上下絕對值差的和,第 i 列與第 i-k 列的左右絕對值差的和 

考慮 k 的范圍：首先我們是從第 i - k列中選了 j - 1列，那么 i - k 一定得大于等于 j - 1 吧（不然怎么選），其次我們要從第 i 列往前找 k 列來作為鄰列，那么顯然 i - k > 0

考慮邊界條件

注意到我們 dp 數組的第一維是要選上該列的，那么如果我們第二維只選一條列的話，那么肯定是選正在枚舉的這一列的，所以就有如下邊界設置：

    for (int i = 1; i <= m; i++)
        dp[i][1] = ver[i];                      //如果只選擇一列肯定是選自己 

上 dp 代碼：

    for (int i = 1; i <= m; i++)                //我們已經找了i列 
        for (int j = 1; j <= c; j++)            //我們一共只選擇c列 
            for (int k = 1; i - k > 0 && i - k >= j - 1; k++)    //找i的鄰列 
                dp[i][j] = min(dp[i][j], dp[i - k][j - 1] + ver[i] + del[i - k][i]);   //狀態轉移方程 
//第 i-k 列是第 i 列的上一列,所以應該要選擇j-1列
//加上新選的第 i 列的貢獻：第i列的上下絕對值差的和,第 i 列與第 i-k 列的左右絕對值差的和 

考慮答案選擇

我們最終肯定是要只選擇 c 列的，所以我們要枚舉每種能夠選擇 c 列的情況，選擇最小得分即可：

    for (int i = c; i <= m; i++)//從c行后取最小值 
        ans = min(ans, dp[i][c]);

完整AC代碼（累死QwQ~）:

#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdio>
#include <cmath>
using namespace std;
int n, m, r, c, ans = 2147483647;
int a[19][19], hang[19], dp[19][19];
int ver[19], del[19][19]; 
/*
a[i][j]:矩陣第i行第j列的數;
dp[i][j]:枚舉列要用,表示前i列我們已經選了j列所得到的最小分值,注意要選第i列（這j列中包含第i列）;
ver[i]:第i列上下絕對值差的和;
del[i][j]:第i列和第j列左右絕對值差的和;
hang[i]:枚舉的子矩陣的第i行在原大矩陣的行數;
*/
inline void Dp()
{              
    memset(dp, 123, sizeof(dp));                //注意不要忘了清空 
    memset(ver, 0, sizeof(ver));
    memset(del, 0, sizeof(del));
    
    for (int i = 1; i <= m; i++)                //枚舉每一列
        for (int j = 2; j <= r; j++)            //枚舉子矩陣的每一行 
            ver[i] += abs(a[hang[j]][i] - a[hang[j - 1]][i]) ;   //利用hang數組回到原矩陣去尋找值 
            
    for (int i = 1; i <= m; i++)                //枚舉每一列 i 
        for (int k = i + 1; k <= m; k++)        //再找 i 之后的列 
            for (int j = 1; j <= r; j++)        //枚舉子矩陣的每一行 
                del[i][k] += abs(a[hang[j]][k] - a[hang[j]][i]); //套定義求出del數組 
    for (int i = 1; i <= m; i++)
        dp[i][1] = ver[i];                      //如果只選擇一列肯定是選自己 
    for (int i = 1; i <= m; i++)                //我們已經找了i列 
        for (int j = 1; j <= c; j++)            //我們一共只選擇c列 
            for (int k = 1; i - k > 0 && i - k >= j - 1; k++)    //找i的鄰列 
                dp[i][j] = min(dp[i][j], dp[i - k][j - 1] + ver[i] + del[i - k][i]);   //狀態轉移方程 
//第 i-k 列是第 i 列的上一列,所以應該要選擇j-1列
//加上新選的第 i 列的貢獻：第i列的上下絕對值差的和,第 i 列與第 i-k 列的左右絕對值差的和 
    for (int i = c; i <= m; i++)//從c行后取最小值 
        ans = min(ans, dp[i][c]); 
}        
void dfs(int now, int pos)        //我們當前正在選第now行,這一行在原矩陣中是第pos行 
{
    if (now == r + 1)             //如果超出了r行,說明我們已經選完了r行,開始進行dp操作 
    {
        Dp();
        return;
    }
    if (pos == n + 1)             //判斷是否在原矩陣范圍內 
        return;
    for (int i = pos; i <= n; i++)//從第pos行開始往后選 
        hang[now] = i, dfs(now + 1, i + 1);  //繼續往下選 
//hang[now]=i :在子矩陣里的第now行就是原矩陣的第i行 
}
int main()
{
    scanf("%d%d%d%d", &n, &m, &r, &c);
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= m; j++)    
            scanf("%d", &a[i][j]);
    dfs(1, 1);
    printf("%d", ans);
}

蟹蟹你的觀看QwQ~

總結

以上是生活随笔為你收集整理的P2258 子矩阵的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。