2021 icpc 沈阳 J-Luggage Lock

比赛结束后，立马和队友开了一场重现，然后被暴打。
 J题是说，给你一把锁，有4位数，每位是0-9，然后给你目前锁的状态，和密码状态，你可以将连续的几个位置同时向上或下拨动，或者你单个位置拨动，问你最后需要几步。
常见的解法应该都是bfs，打个表，从0000开始拨动到任意位置所需的最小步，我一开始也是这么想的，但是不知道为什么脑子一抽最后选择了状压dp。
解法：
 很容易知道，一个位置要么往上拨要么往下拨，那么每一位其实就是2种情况，4位就是222*2=16种情况。
 如果所有位置单独拨动的话ans=need[1]+need[2]+need[3]+need[3]，need[i]即第i位从初始态拨到最终态所需的步数。
 如果当连续的两位(i,j)同时向上（或下）拨动，需要的最小步数很容易发现是max(need[i],need[j])。
 如果当连续的三位(i,j,k)同时拨动，那么就有三种情况，前两种是need[i]或need[k]是最小的，那么显而易见就会退化成连续两位(i,j)拨动的情况，第三种就是need[j]是最小的，那么这时候，很显然，j是最先到达最终态的，那么这时候将i和k分别拨完剩下的步数就行了，那么ans=need[j]+(need[i]-need[j])+(need[k]-need[j]) 即ans=need[i]+need[k]-need[j]。
 如果当连续的四位(i,j,k,t)同时拨动，那么就有四种情况，前两种就是need[i]或need[t]最小的，那么显然就会退化成连续三位(i,j,k)拨动的情况，那么剩下两种就是need[j]或need[k]最小的，很容易得到ans=need[i]+max(need[k],need[t])-need[j]和ans=need[t]+max(need[i],need[j])-need[k]，即是连续三位拨动和连续两位拨动的结合体。
 除了上述，还要考虑一种情况，当某位need[x]==0时，此时可以将它连同其他的一起拨动，最后再拨回原来的位置，也就是说此时必定有ans<=10。

#include <iostream>
#include<bits/stdc++.h>
#define scd(x) scanf("%d",&x)
#define scdd(x,y) scanf("%d%d",&x,&y)
#define scddd(x,y,z) scanf("%d%d%d",&x,&y,&z)
#define mst(x,y) memset(x,y,sizeof(x));
using namespace std;
typedef long long ll;
const int maxn=1e2+5;
int a[10],b[10];
int sum(int p[5],int len)
{
    int mn=100,mx=0;
    if(len==4)
    {
        for(int i=1;i<=4;i++)mn=min(mn,p[i]),mx=max(mx,p[i]);
        if(p[2]==mn)return p[1]+max(p[3],p[4])-p[2];
        if(p[3]==mn)return max(p[1],p[2])+p[4]-p[3];
        if(p[1]==mn)return sum(p+1,3);
        else return sum(p,3);
    }
    else
    {
        for(int i=1;i<=3;i++)mn=min(mn,p[i]),mx=max(mx,p[i]);
        if(mn==p[2])return p[1]+p[3]-p[2];
        return mx;
    }
}
int g(int k,int flag)
{
    if(flag==0)
    {
        return a[k]<=b[k]?b[k]-a[k]:b[k]+10-a[k];
    }
    return a[k]>=b[k]?a[k]-b[k]:a[k]+10-b[k];
}
int main()
{
    #ifdef local
    freopen("1.txt","r",stdin);
    #endif // local
    int T;
    scd(T);
    while(T--)
    {
        int ans=100;
        char s[maxn];
        scanf("%s",s+1);
        for(int i=1;i<=4;i++)a[i]=s[i]-'0';
        scanf("%s",s+1);
        for(int i=1;i<=4;i++)b[i]=s[i]-'0';
        for(int i=0;i<=(1<<4)-1;i++)
        {
            int t=i;
            int p[5];
            int x[5];
            for(int j=1;j<=4;j++)x[j]=(t>>(j-1))&1;
            for(int j=1;j<=4;j++)p[j]=g(j,x[j]);
            for(int j=1;j<=4;j++)
                if(p[j]==0)
                    ans=min(ans,10);
            if(x[2]==x[3])//2==3
            {
                if(x[1]==x[2])//1==2==3
                {
                    if(x[4]==x[2])//1==2==3==4
                        ans=min(ans,sum(p,4));
                    else//1==2==3!=4
                        ans=min(ans,sum(p,3)+p[4]);
                }
                else if(x[4]==x[2])//1!=2==3==4
                    ans=min(ans,sum(p+1,3)+p[1]);
                else//0!=1==2!=3
                    ans=min(p[1]+max(p[2],p[3])+p[4],ans);
            }
            else if(x[1]==x[2]&&x[3]==x[4])ans=min(ans,max(p[1],p[2])+max(p[3],p[4]));
            else if(x[1]==x[2]&&x[3]!=x[4])ans=min(ans,max(p[1],p[2])+p[3]+p[4]);
            else if(x[1]!=x[2]&&x[3]==x[4])ans=min(ans,p[1]+p[2]+max(p[3],p[4]));
            else ans=min(ans,p[1]+p[2]+p[3]+p[4]);
        }
        printf("%d\n",ans);
    }
    return 0;
}

只能说还是bfs简单多了，不知道为什么硬要想状压dp折磨自己，要考虑这么多种情况。