CCPC 2022 威海 D - Sternhalma

 棋盘3+4+5+4+3=19格，所以可以用[0,1<<19)表示所有状态。根据棋子的移动规则，棋子只会变少，所以棋子少的状态可以更新棋子多的状态。然后预处理所有状态能到多少，最后多组输入直接查表。具体解释见下面代码

//我的样例解释见代码最低端
#include <bits/stdc++.h>
using namespace std;
#define int long long
const int N = 20;
#define xx first
#define yy second
#define PII pair<int, int>
#define pb push_back
int f[1 << N];     // dp数组
int a[20];         //记19个位置的分数
vector<PII> q[25]; //跳棋规则
int len[25];       //对应上面每一个q数组大小，每一次用算.size()可能会慢，提前处理
void iniit()
{                                          //对应编号可到哪些点，第一个（xx）存的是被跳过的，第二个（yy)存的是出发点，具体解释见下
    q[18].pb({15, 11}), q[18].pb({14, 9}); // 9 跳过 14 到达18
    q[17].pb({14, 10}), q[17].pb({13, 8});
    q[16].pb({13, 9}), q[16].pb({12, 7});
    q[15].pb({10, 5}), q[12].pb({8, 4});
    q[14].pb({10, 6}), q[14].pb({9, 4});
    q[13].pb({9, 5}), q[13].pb({8, 3});
    q[11].pb({6, 2}), q[11].pb({15, 18});
    q[10].pb({14, 17}), q[10].pb({5, 1});
    q[9].pb({14, 18}), q[9].pb({13, 16});
    q[9].pb({5, 2}), q[9].pb({4, 0});
    q[8].pb({13, 17}), q[8].pb({4, 1});
    q[7].pb({12, 16}), q[7].pb({3, 0});
    q[6].pb({10, 14}), q[3].pb({8, 13});
    q[5].pb({9, 13}), q[5].pb({10, 15});
    q[4].pb({8, 12}), q[4].pb({9, 14});
    q[2].pb({5, 9}), q[2].pb({6, 11});
    q[1].pb({4, 8}), q[1].pb({5, 10});
    q[0].pb({3, 7}), q[0].pb({4, 9});
    //以上为竖着跳，以下为横着跳
    for (int i = 18; i >= 0; i--)
    {
        if (i == 18 || i == 15 || i == 14 || i == 11 || i == 10 || i == 9 || i == 6 || i == 5 || i == 2)
            q[i].pb({i - 1, i - 2});
        //以上为向右跳，以下为向左跳
        if (i == 16 || i == 12 || i == 13 || i == 7 || i == 8 || i == 9 || i == 3 || i == 4 || i == 0)
            q[i].pb({i + 1, i + 2});
    }
    for (int i = 0; i < 19; i++)
        len[i] = q[i].size();
}
//我写的麻烦了，别的题解写法↓，但是大概意思就是这样
/*
int d1[5][6][2] = {//d1[i]表示第i行的位置往六个方向移动一格的坐标增量
    {
        {-1, -1}, {-1, 0}, {0, -1}, {0, 1}, {1, 0}, {1, 1},
    },
    {
        {-1, -1}, {-1, 0}, {0, -1}, {0, 1}, {1, 0}, {1, 1},
    },
    {
        {-1, -1}, {-1, 0}, {0, -1}, {0, 1}, {1, -1}, {1, 0},
    },
    {
        {-1, 0}, {-1, 1}, {0, -1}, {0, 1}, {1, -1}, {1, 0},
    },
    {
        {-1, 0}, {-1, 1}, {0, -1}, {0, 1}, {1, -1}, {1, 0},
    }
};
int d2[5][6][2] = {//d2[i]表示第i行的位置往六个方向移动两格的坐标增量
    {
        {-2, -2}, {-2, 0}, {0, -2}, {0, 2}, {2, 0}, {2, 2},
    },
    {
        {-2, -2}, {-2, 0}, {0, -2}, {0, 2}, {2, -1}, {2, 1},
    },
    {
        {-2, -2}, {-2, 0}, {0, -2}, {0, 2}, {2, -2}, {2, 0},
    },
    {
        {-2, -1}, {-2, 1}, {0, -2}, {0, 2}, {2, -2}, {2, 0},
    },
    {
        {-2, 0}, {-2, 2}, {0, -2}, {0, 2}, {2, -2}, {2, 0},
    }
};
*/
int count(int k) //数有几个1
{
    int ans = 0;
    for (int i = 0; i < 19; i++)
    {
        if (k & (1 << i))
            ans++;
    }
    return ans;
}
vector<int> can[25]; // can[i]表示有i个1的数是那些，用到size的地方不多，就不像上面那个一样开个数组存size了
void init()
{
    iniit(); //打表
    int i, j, k, n, m, nn, x, mm, kk, ww;
    for (i = 0; i < (1 << 19); i++)
    {
        can[count(i)].pb(i); //把每个数分类
    }
    // 1个棋子变成0个只能是移除，并不会改变分数，改变分数至少是2个旗子，跳成1个棋子
    for (i = 1; i <= 18; i++) //枚举还剩多少颗棋子，i颗棋子可以有i+1颗棋子调成，所以可以更新i+1个棋子的状态，一共19,枚举到剩18就行
    {
        nn = can[i].size();
        for (j = 0; j < nn; j++) // i个棋子的所有数
        {
            x = can[i][j];
            for (k = 0; k < 19; k++)
            {
                if (x & (1 << k)) //这个数这个位置有棋子
                {
                    for (kk = 0; kk < len[k]; kk++) //这个位置可以哪些位置变过来
                    //例：9 跳过 14 到达18，那么18有棋子，9&&14无棋子，就可以是9&&14有棋子，18无棋子这一状态变过来的
                    {
                        if (!(x & (1 << q[k][kk].xx)) && !(x & (1 << q[k][kk].yy)))
                        {
                            ww = x ^ (1 << k) ^ (1 << q[k][kk].xx) ^ (1 << q[k][kk].yy); //找出这个数是谁
                            f[ww] = max(f[ww], f[x] + a[q[k][kk].xx]);                   //加上被跳过的位置的分数
                        }
                    }
                }
                else //这个位置无棋子，可以是原本有棋子，直接移除了
                {
                    ww = x ^ (1 << k);
                    f[ww] = max(f[ww], f[x]); //直接移除不得分
                }
            }
        }
    }
    return;
}
char s[15]; //存读入
signed main()
{
    int k, n, i, j, m;
    for (i = 18; i >= 0; i--)
        scanf("%lld", &a[i]);
    init(); //预处理
    int t;
    cin >> t;
    while (t--)
    {
        m = 0;
        k = 19;//k表示当前时第几个编号的位置
        for (i = 1; i < 6; i++)
        {
            scanf("%s", s);
            n = strlen(s);
            for (j = 0; j < n; j++)
            {
                k--;
                if (s[j] == '#') //找棋子位置
                    m += 1 << k;
            }
        }
        printf("%lld\n", f[m]);
    }
    return 0;
}

/*
样例对应我的图，左编号，右得分
    18  17  16                 9   2   2
  15  14  13  12             3   3   7   2
11  10   9   8   7         0   3   6   8   5
   6   5   4   3             4   7   7   5
     2   1   0                 8   0   7
*/