插头DP 专题

最新推荐文章于 2018-08-24 15:48:00 发布
最新推荐文章于 2018-08-24 15:48:00 发布
阅读量503 收藏 2
点赞数
分类专栏： 插头DP # 系列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nike0good/article/details/53563874
版权

插头dp 整理

先贴一份大牛的代码参考一下

HDU 1693 Eat the Trees

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<algorithm>
using namespace std;
#define For(i,n) for(int i=1;i<=n;i++)
const int HASH=10009;
const int STATE=1000010;
const int MAXD=15;
int N,M;
int code[MAXD],maze[MAXD][MAXD];
struct HASHMAP
{
    int head[HASH],next[STATE],state[STATE],size;
    long long f[STATE];
    void init()
    {
        size=0;
        memset(head,-1,sizeof(head));
    }
    void push(int st,long long ans)
    {
        int i,h=st%HASH;
        for(i=head[h];i!=-1;i=next[i])
          if(st==state[i])
          {
              f[i]+=ans;
              return;
          }
        f[size]=ans;
        state[size]=st;
        next[size]=head[h];
        head[h]=size++;
    }
}hm[2];

void decode(int *code,int m,int st)
{
    int i;
    for(i=m;i>=0;i--)
    {
        code[i]=st&1;
        st>>=1;
    }
}
int encode(int *code,int m)
{
    int i,st=0;
    for(int i=0;i<=m;i++)
    {
        st<<=1;
        st|=code[i];
    }
    return st;
}
void init()
{
    scanf("%d%d",&N,&M);
    for(int i=1;i<=N;i++)
      for(int j=1;j<=M;j++)
        scanf("%d",&maze[i][j]);
    for(int i=1;i<=N;i++)maze[i][M+1]=0;
    for(int i=1;i<=M;i++)maze[N+1][i]=0;
}

void shift(int *code,int m)//循环右移 
{
    int i;
    for(i=m;i>0;i--)
      code[i]=code[i-1];
    code[0]=0;
}

void dpblank(int i,int j,int cur)
{
    int k,left,up;
    for(k=0;k<hm[cur].size;k++)
    {
        decode(code,M,hm[cur].state[k]);
        left=code[j-1];
        up=code[j];
        if(left&&up)//11  -> 00
        {
            code[j-1]=code[j]=0;
            if(j==M)shift(code,M);
            hm[cur^1].push(encode(code,M),hm[cur].f[k]);
        }
        else if(left||up)
        {
            if(maze[i][j+1])
            {
                code[j-1]=0;
                code[j]=1;
                hm[cur^1].push(encode(code,M),hm[cur].f[k]);
            }
            if(maze[i+1][j])
            {
                code[j-1]=1;
                code[j]=0;
                if(j==M)shift(code,M);
                hm[cur^1].push(encode(code,M),hm[cur].f[k]);
            }
        }
        else
        {
            if(maze[i][j+1]&&maze[i+1][j])
            {
                code[j]=code[j-1]=1;
                hm[cur^1].push(encode(code,M),hm[cur].f[k]);
            }
        }
    }
}

void dpblock(int i,int j,int cur)
{
    int k;
    for(k=0;k<hm[cur].size;k++)
    {
        decode(code,M,hm[cur].state[k]);
        code[j-1]=code[j]=0;
        if(j==M)shift(code,M);
        hm[cur^1].push(encode(code,M),hm[cur].f[k]);
    }
}

void solve()
{
    int i,j,cur=0;
    long long ans=0;
    hm[cur].init();
    hm[cur].push(0,1);
    for(i=1;i<=N;i++)
      for(j=1;j<=M;j++)
      {
          hm[cur^1].init();
          if(maze[i][j])dpblank(i,j,cur);
          else dpblock(i,j,cur);
          cur^=1;
      }
    for(i=0;i<hm[cur].size;i++)
      ans+=hm[cur].f[i];
    printf("There are %I64d ways to eat the trees.\n",ans);
}
int main()
{
    freopen("hdu1693.in","r",stdin);
    int T;
    scanf("%d",&T);
    For(iCase,T)
    {
        printf("Case %d: ",iCase);
        init();
        solve();
    }
    return 0;
}

URAL 1519. Formula 1 /BZOJ 1814

单回路问题
我们用括号表示法
参考cdq的《基于连通性状态压缩的动态规划问题》
注意
特判1个插头都没有的情况
只有最后一个不是障碍的格子才能连出回路

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
#define For(i,n) for(int i=1;i<=n;i++)
const int HASH=30007;
const int STATE=1000010;
const int MAXD=15;
int N,M;
int code[MAXD];
char maze[MAXD][MAXD];
typedef unsigned long long ll; 
struct HASHMAP
{
    int head[HASH],next[STATE],state[STATE],size;
    ll f[STATE];
    void init()
    {
        size=0;
        memset(head,-1,sizeof(head));
    }
    void push(int st,ll ans)
    {
        int i,h=st%HASH;
        for(i=head[h];i!=-1;i=next[i])
          if(st==state[i])
          {
              f[i]+=ans;
              return;
          }
        f[size]=ans;
        state[size]=st;
        next[size]=head[h];
        head[h]=size++;
    }
}hm[2];

void decode(int *code,int m,int st)
{
    int i;
    for(i=m;i>=0;i--)
    {
        code[i]=st&3;
        st>>=2;
    }
}
int encode(int *code,int m)
{
    int i,st=0;
    for(int i=0;i<=m;i++)
    {
        st<<=2;
        st|=code[i];
    }
    return st;
}
void init()
{
    scanf("%d%d",&N,&M);
    for(int i=1;i<=N;i++)  
        scanf("%s",maze[i]+1);
    For(i,N) For(j,M) if (maze[i][j]=='*') maze[i][j]=0;
    for(int i=1;i<=N;i++)maze[i][M+1]=0;
    for(int i=1;i<=M;i++)maze[N+1][i]=0;
}

void shift(int *code,int m)//循环右移 
{
    int i;
    for(i=m;i>0;i--)
      code[i]=code[i-1];
    code[0]=0;
}
#include<stack>
int seq[MAXD];
void prs(int *code,int m,int *seq) {
    stack<int> st;
    for(int i=0;i<=m;i++) {
        if (code[i]==1) st.push(i);
        if (code[i]==2) {
            int f=st.top(); st.pop();
            seq[f]=i;seq[i]=f;
        }
    }
}
int ex,ey;
void dpblank(int i,int j,int cur)
{
    int k,left,up;
    for(k=0;k<hm[cur].size;k++)
    {
        decode(code,M,hm[cur].state[k]);
        prs(code,M,seq);
        left=code[j-1];
        up=code[j];
        if(left&&up)//11  -> 00
        {
            if (left==1&&up==1) {
                code[j-1]=code[j]=0;
                code[seq[j]]=1;
                if(j==M)shift(code,M);
                hm[cur^1].push(encode(code,M),hm[cur].f[k]);
            }
            if (left==1&&up==2) if (i==ex&&j==ey){
                code[j-1]=code[j]=0;
                if(j==M)shift(code,M);
                hm[cur^1].push(encode(code,M),hm[cur].f[k]);
            }
            if (left==2&&up==1) {
                code[j-1]=code[j]=0;
                if(j==M)shift(code,M);
                hm[cur^1].push(encode(code,M),hm[cur].f[k]);
            }
            if (left==2&&up==2) {
                code[j-1]=code[j]=0;
                code[seq[j-1]]=2;
                if(j==M)shift(code,M);
                hm[cur^1].push(encode(code,M),hm[cur].f[k]);
            }
        }
        else if(left+up)
        {
            if(maze[i][j+1])
            {
                code[j-1]=0;
                code[j]=left|up;
                hm[cur^1].push(encode(code,M),hm[cur].f[k]);
            }
            if(maze[i+1][j])
            {
                code[j-1]=left|up;
                code[j]=0;
                if(j==M)shift(code,M);
                hm[cur^1].push(encode(code,M),hm[cur].f[k]);
            }
        }
        else
        {
            if(maze[i][j+1]&&maze[i+1][j])
            {
                code[j-1]=1,code[j]=2;
                hm[cur^1].push(encode(code,M),hm[cur].f[k]);
            }
        }
    }
}

void dpblock(int i,int j,int cur)
{
    int k;
    for(k=0;k<hm[cur].size;k++)
    {
        decode(code,M,hm[cur].state[k]);
        code[j-1]=code[j]=0;
        if(j==M)shift(code,M);
        hm[cur^1].push(encode(code,M),hm[cur].f[k]);
    }
}

void solve()
{
    bool fl=0;
    For(i,N) For(j,M) if (maze[i][j]) fl=1,ex=i,ey=j;
    if(!fl) {
        puts("0");return;
    }

    int i,j,cur=0;
    ll ans=0;
    hm[cur].init();
    hm[cur].push(0,1);
    for(i=1;i<=N;i++)
      for(j=1;j<=M;j++)
      {
          hm[cur^1].init();
          if(maze[i][j])dpblank(i,j,cur);
          else dpblock(i,j,cur);
          cur^=1;
      }
    for(i=0;i<hm[cur].size;i++)
      ans+=(hm[cur].state[i]==0)*hm[cur].f[i];
    cout<<ans<<endl; 
}
int main()
{
    freopen("ural1519.in","r",stdin);
    init();
    solve();
    return 0;
}

BZOJ 1210: [HNOI2004]邮递员

答案显然为汉密尔顿回路*2，特判: n=1||m=1 时 ans=1 

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
#include<bits/stdc++.h>

struct BigInteger {
    typedef unsigned long long LL;

    static const int BASE = 100000000;
    static const int WIDTH = 8;
    vector<int> s;

    BigInteger& clean(){while(!s.back()&&s.size()>1)s.pop_back(); return *this;}
    BigInteger(LL num = 0) {*this = num;}
    BigInteger(string s) {*this = s;}
    BigInteger& operator = (long long num) {
        s.clear();
        do {
            s.push_back(num % BASE);
            num /= BASE;
        } while (num > 0);
        return *this;
    }
    BigInteger& operator = (const string& str) {
        s.clear();
        int x, len = (str.length() - 1) / WIDTH + 1;
        for (int i = 0; i < len; i++) {
            int end = str.length() - i*WIDTH;
            int start = max(0, end - WIDTH);
            sscanf(str.substr(start,end-start).c_str(), "%d", &x);
            s.push_back(x);
        }
        return (*this).clean();
    }

    BigInteger operator + (const BigInteger& b) const {
        BigInteger c; c.s.clear();
        for (int i = 0, g = 0; ; i++) {
            if (g == 0 && i >= s.size() && i >= b.s.size()) break;
            int x = g;
            if (i < s.size()) x += s[i];
            if (i < b.s.size()) x += b.s[i];
            c.s.push_back(x % BASE);
            g = x / BASE;
        }
        return c;
    }
    BigInteger operator - (const BigInteger& b) const {
        assert(b <= *this); // ¼õÊý²»ÄÜ´óÓÚ±»¼õÊý
        BigInteger c; c.s.clear();
        for (int i = 0, g = 0; ; i++) {
            if (g == 0 && i >= s.size() && i >= b.s.size()) break;
            int x = s[i] + g;
            if (i < b.s.size()) x -= b.s[i];
            if (x < 0) {g = -1; x += BASE;} else g = 0;
            c.s.push_back(x);
        }
        return c.clean();
    }
    BigInteger operator * (const BigInteger& b) const {
        int i, j; LL g;
        vector<LL> v(s.size()+b.s.size(), 0);
        BigInteger c; c.s.clear();
        for(i=0;i<s.size();i++) for(j=0;j<b.s.size();j++) v[i+j]+=LL(s[i])*b.s[j];
        for (i = 0, g = 0; ; i++) {
            if (g ==0 && i >= v.size()) break;
            LL x = v[i] + g;
            c.s.push_back(x % BASE);
            g = x / BASE;
        }
        return c.clean();
    }
    BigInteger operator / (const BigInteger& b) const {
        assert(b > 0);  // ³ýÊý±ØÐë´óÓÚ0
        BigInteger c = *this;       // ÉÌ:Ö÷ÒªÊÇÈÃc.sºÍ(*this).sµÄvectorÒ»Ñù´ó
        BigInteger m;               // ÓàÊý:³õʼ»¯Îª0
        for (int i = s.size()-1; i >= 0; i--) {
            m = m*BASE + s[i];
            c.s[i] = bsearch(b, m);
            m -= b*c.s[i];
        }
        return c.clean();
    }
    BigInteger operator % (const BigInteger& b) const { //·½·¨Óë³ý·¨Ïàͬ
        BigInteger c = *this;
        BigInteger m;
        for (int i = s.size()-1; i >= 0; i--) {
            m = m*BASE + s[i];
            c.s[i] = bsearch(b, m);
            m -= b*c.s[i];
        }
        return m;
    }
    // ¶þ·Ö·¨ÕÒ³öÂú×ãbx<=mµÄ×î´óµÄx
    int bsearch(const BigInteger& b, const BigInteger& m) const{
        int L = 0, R = BASE-1, x;
        while (1) {
            x = (L+R)>>1;
            if (b*x<=m) {if (b*(x+1)>m) return x; else L = x;}
            else R = x;
        }
    }
    BigInteger& operator += (const BigInteger& b) {*this = *this + b; return *this;}
    BigInteger& operator -= (const BigInteger& b) {*this = *this - b; return *this;}
    BigInteger& operator *= (const BigInteger& b) {*this = *this * b; return *this;}
    BigInteger& operator /= (const BigInteger& b) {*this = *this / b; return *this;}
    BigInteger& operator %= (const BigInteger& b) {*this = *this % b; return *this;}

    bool operator < (const BigInteger& b) const {
        if (s.size() != b.s.size()) return s.size() < b.s.size();
        for (int i = s.size()-1; i >= 0; i--)
            if (s[i] != b.s[i]) return s[i] < b.s[i];
        return false;
    }
    bool operator >(const BigInteger& b) const{return b < *this;}
    bool operator<=(const BigInteger& b) const{return !(b < *this);}
    bool operator>=(const BigInteger& b) const{return !(*this < b);}
    bool operator!=(const BigInteger& b) const{return b < *this || *this < b;}
    bool operator==(const BigInteger& b) const{return !(b < *this) && !(b > *this);}
};

ostream& operator << (ostream& out, const BigInteger& x) {
    out << x.s.back();
    for (int i = x.s.size()-2; i >= 0; i--) {
        char buf[20];
        sprintf(buf, "%08d", x.s[i]);
        for (int j = 0; j < strlen(buf); j++) out << buf[j];
    }
    return out;
}

istream& operator >> (istream& in, BigInteger& x) {
    string s;
    if (!(in >> s)) return in;
    x = s;
    return in;
}

#define For(i,n) for(int i=1;i<=n;i++)
const int HASH=30007;
const int STATE=1000010;
const int MAXD=25;
int N,M;
int code[MAXD];
char maze[MAXD][MAXD];
typedef BigInteger ll; 
struct HASHMAP
{
    int head[HASH],next[STATE],state[STATE],size;
    ll f[STATE];
    void init()
    {
        size=0;
        memset(head,-1,sizeof(head));
    }
    void push(int st,ll ans)
    {
        int i,h=st%HASH;
        for(i=head[h];i!=-1;i=next[i])
          if(st==state[i])
          {
              f[i]+=ans;
              return;
          }
        f[size]=ans;
        state[size]=st;
        next[size]=head[h];
        head[h]=size++;
    }
}hm[2];

void decode(int *code,int m,int st)
{
    int i;
    for(i=m;i>=0;i--)
    {
        code[i]=st&3;
        st>>=2;
    }
}
int encode(int *code,int m)
{
    int i,st=0;
    for(int i=0;i<=m;i++)
    {
        st<<=2;
        st|=code[i];
    }
    return st;
}
void init()
{
    scanf("%d%d",&N,&M);
    if (N<M)swap(N,M);
    For(i,N) For(j,M) maze[i][j]=1;
    for(int i=1;i<=N;i++)maze[i][M+1]=0;
    for(int i=1;i<=M;i++)maze[N+1][i]=0;
}

void shift(int *code,int m)//Ñ­»·ÓÒÒÆ 
{
    int i;
    for(i=m;i>0;i--)
      code[i]=code[i-1];
    code[0]=0;
}
#include<stack>
int seq[MAXD];
void prs(int *code,int m,int *seq) {
    stack<int> st;
    for(int i=0;i<=m;i++) {
        if (code[i]==1) st.push(i);
        if (code[i]==2) {
            int f=st.top(); st.pop();
            seq[f]=i;seq[i]=f;
        }
    }
}
int ex,ey;
void dpblank(int i,int j,int cur)
{
    int k,left,up;
    for(k=0;k<hm[cur].size;k++)
    {
        decode(code,M,hm[cur].state[k]);
        prs(code,M,seq);
        left=code[j-1];
        up=code[j];
        if(left&&up)//11  -> 00
        {
            if (left==1&&up==1) {
                code[j-1]=code[j]=0;
                code[seq[j]]=1;
                if(j==M)shift(code,M);
                hm[cur^1].push(encode(code,M),hm[cur].f[k]);
            }
            if (left==1&&up==2) if (i==ex&&j==ey){
                code[j-1]=code[j]=0;
                if(j==M)shift(code,M);
                hm[cur^1].push(encode(code,M),hm[cur].f[k]);
            }
            if (left==2&&up==1) {
                code[j-1]=code[j]=0;
                if(j==M)shift(code,M);
                hm[cur^1].push(encode(code,M),hm[cur].f[k]);
            }
            if (left==2&&up==2) {
                code[j-1]=code[j]=0;
                code[seq[j-1]]=2;
                if(j==M)shift(code,M);
                hm[cur^1].push(encode(code,M),hm[cur].f[k]);
            }
        }
        else if(left+up)
        {
            if(maze[i][j+1])
            {
                code[j-1]=0;
                code[j]=left|up;
                hm[cur^1].push(encode(code,M),hm[cur].f[k]);
            }
            if(maze[i+1][j])
            {
                code[j-1]=left|up;
                code[j]=0;
                if(j==M)shift(code,M);
                hm[cur^1].push(encode(code,M),hm[cur].f[k]);
            }
        }
        else
        {
            if(maze[i][j+1]&&maze[i+1][j])
            {
                code[j-1]=1,code[j]=2;
                hm[cur^1].push(encode(code,M),hm[cur].f[k]);
            }
        }
    }
}

void dpblock(int i,int j,int cur)
{
    int k;
    for(k=0;k<hm[cur].size;k++)
    {
        decode(code,M,hm[cur].state[k]);
        code[j-1]=code[j]=0;
        if(j==M)shift(code,M);
        hm[cur^1].push(encode(code,M),hm[cur].f[k]);
    }
}

void solve()
{
    ex=N,ey=M;
    if(M==1) {
        puts("1");return;
    }

    int i,j,cur=0;
    ll ans=0;
    hm[cur].init();
    hm[cur].push(0,1);
    for(i=1;i<=N;i++)
      for(j=1;j<=M;j++)
      {
          hm[cur^1].init();
          if(maze[i][j])dpblank(i,j,cur);
          else dpblock(i,j,cur);
          cur^=1;
      }
    for(i=0;i<hm[cur].size;i++)
      ans+=hm[cur].f[i];
    cout<<(ans+ans)<<endl; 
}
int main()
{
//  freopen("bzoj1210.in","r",stdin);
    init();
    solve();
    return 0;
}

BZOJ 3125: CITY

同URAL 1519，只不过有一些边被限制只能走上下或左右

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
#define For(i,n) for(int i=1;i<=n;i++)
const int HASH=30007;
const int STATE=1000010;
const int MAXD=15;
int N,M;
int code[MAXD];
char maze[MAXD][MAXD];
typedef unsigned long long ll; 
struct HASHMAP
{
    int head[HASH],next[STATE],state[STATE],size;
    ll f[STATE];
    void init()
    {
        size=0;
        memset(head,-1,sizeof(head));
    }
    void push(int st,ll ans)
    {
        int i,h=st%HASH;
        for(i=head[h];i!=-1;i=next[i])
          if(st==state[i])
          {
              f[i]+=ans;
              return;
          }
        f[size]=ans;
        state[size]=st;
        next[size]=head[h];
        head[h]=size++;
    }
}hm[2];

void decode(int *code,int m,int st)
{
    int i;
    for(i=m;i>=0;i--)
    {
        code[i]=st&3;
        st>>=2;
    }
}
int encode(int *code,int m)
{
    int i,st=0;
    for(int i=0;i<=m;i++)
    {
        st<<=2;
        st|=code[i];
    }
    return st;
}
void init()
{
    scanf("%d%d",&N,&M);
    for(int i=1;i<=N;i++)  
        scanf("%s",maze[i]+1);
    For(i,N) For(j,M) if (maze[i][j]=='#') maze[i][j]=0;
    for(int i=1;i<=N;i++)maze[i][M+1]=0;
    for(int i=1;i<=M;i++)maze[N+1][i]=0;
}

void shift(int *code,int m)//循环右移 
{
    int i;
    for(i=m;i>0;i--)
      code[i]=code[i-1];
    code[0]=0;
}
#include<stack>
int seq[MAXD];
void prs(int *code,int m,int *seq) {
    stack<int> st;
    for(int i=0;i<=m;i++) {
        if (code[i]==1) st.push(i);
        if (code[i]==2) {
            int f=st.top(); st.pop();
            seq[f]=i;seq[i]=f;
        }
    }
}
int ex,ey;
void dpblank(int i,int j,int cur)
{
    int k,left,up;
    for(k=0;k<hm[cur].size;k++)
    {
        decode(code,M,hm[cur].state[k]);
        prs(code,M,seq);
        left=code[j-1];
        up=code[j];
        if(left&&up)//11  -> 00
        {
            if (maze[i][j+1]=='-' || maze[i+1][j]=='|' || maze[i][j]!='.') continue;
            if (left==1&&up==1) {
                code[j-1]=code[j]=0;
                code[seq[j]]=1;
                if(j==M)shift(code,M);
                hm[cur^1].push(encode(code,M),hm[cur].f[k]);
            }
            if (left==1&&up==2) if (i==ex&&j==ey){
                code[j-1]=code[j]=0;
                if(j==M)shift(code,M);
                hm[cur^1].push(encode(code,M),hm[cur].f[k]);
            }
            if (left==2&&up==1) {
                code[j-1]=code[j]=0;
                if(j==M)shift(code,M);
                hm[cur^1].push(encode(code,M),hm[cur].f[k]);
            }
            if (left==2&&up==2) {
                code[j-1]=code[j]=0;
                code[seq[j-1]]=2;
                if(j==M)shift(code,M);
                hm[cur^1].push(encode(code,M),hm[cur].f[k]);
            }
        }
        else if(left+up)
        {
            if ((maze[i][j+1]=='.' || maze[i][j+1]=='-') && (maze[i][j]=='.' || (maze[i][j]=='-' && left )))
            {
                code[j-1]=0;
                code[j]=left|up;
                hm[cur^1].push(encode(code,M),hm[cur].f[k]);
            }
            if((maze[i+1][j]=='.' || maze[i+1][j]=='|') && (maze[i][j]=='.' || (maze[i][j]=='|' && up )))
            {
                code[j-1]=left|up;
                code[j]=0;
                if(j==M)shift(code,M);
                hm[cur^1].push(encode(code,M),hm[cur].f[k]);
            }
        }
        else
        {
            if(maze[i][j+1]&&maze[i+1][j])
            {
                if (maze[i][j+1]=='|' || maze[i+1][j]=='-' || maze[i][j]!='.') continue;
                code[j-1]=1,code[j]=2;
                hm[cur^1].push(encode(code,M),hm[cur].f[k]);
            }
        }
    }
}

void dpblock(int i,int j,int cur)
{
    int k;
    for(k=0;k<hm[cur].size;k++)
    {
        decode(code,M,hm[cur].state[k]);
        code[j-1]=code[j]=0;
        if(j==M)shift(code,M);
        hm[cur^1].push(encode(code,M),hm[cur].f[k]);
    }
}

void solve()
{
    bool fl=0;
    For(i,N) For(j,M) if (maze[i][j]) fl=1,ex=i,ey=j;
    if(!fl) {
        puts("0");return;
    }

    int i,j,cur=0;
    ll ans=0;
    hm[cur].init();
    hm[cur].push(0,1);
    for(i=1;i<=N;i++)
      for(j=1;j<=M;j++)
      {
          hm[cur^1].init();
          if(maze[i][j])dpblank(i,j,cur);
          else dpblock(i,j,cur);
          cur^=1;
      }
    for(i=0;i<hm[cur].size;i++)
      ans+=hm[cur].f[i];
    cout<<ans<<endl; 
}
int main()
{
//  freopen("bzoj3125.in","r",stdin);
    init();
    solve();
    return 0;
}

POJ 1739 Tony’s Tour

从左下到右下的方案数

加2行就行

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
#define For(i,n) for(int i=1;i<=n;i++)
#define Fork(i,k,n) for(int i=k;i<=n;i++)
const int HASH=30007;
const int STATE=1000010;
const int MAXD=15;
int N,M;
int code[MAXD];
char maze[MAXD][MAXD];
typedef unsigned long long ll; 
struct HASHMAP
{
    int head[HASH],next[STATE],state[STATE],size;
    ll f[STATE];
    void init()
    {
        size=0;
        memset(head,-1,sizeof(head));
    }
    void push(int st,ll ans)
    {
        int i,h=st%HASH;
        for(i=head[h];i!=-1;i=next[i])
          if(st==state[i])
          {
              f[i]+=ans;
              return;
          }
        f[size]=ans;
        state[size]=st;
        next[size]=head[h];
        head[h]=size++;
    }
}hm[2];

void decode(int *code,int m,int st)
{
    int i;
    for(i=m;i>=0;i--)
    {
        code[i]=st&3;
        st>>=2;
    }
}
int encode(int *code,int m)
{
    int i,st=0;
    for(int i=0;i<=m;i++)
    {
        st<<=2;
        st|=code[i];
    }
    return st;
}
void init()
{
    scanf("%d%d",&N,&M);
    if (!N&&!M) return;
    for(int i=1;i<=N;i++)  
        scanf("%s",maze[i]+1);
    N+=2;
    Fork(i,N-1,N) For(j,M) 
        maze[i][j]=(i==N||j==1||j==M);

    For(i,N) For(j,M) if (maze[i][j]=='#') maze[i][j]=0;
    for(int i=1;i<=N;i++)maze[i][M+1]=0;
    for(int i=1;i<=M;i++)maze[N+1][i]=0;
}

void shift(int *code,int m)//Ñ­»·ÓÒÒÆ 
{
    int i;
    for(i=m;i>0;i--)
      code[i]=code[i-1];
    code[0]=0;
}
#include<stack>
int seq[MAXD];
void prs(int *code,int m,int *seq) {
    stack<int> st;
    for(int i=0;i<=m;i++) {
        if (code[i]==1) st.push(i);
        if (code[i]==2) {
            int f=st.top(); st.pop();
            seq[f]=i;seq[i]=f;
        }
    }
}
int ex,ey;
void dpblank(int i,int j,int cur)
{
    int k,left,up;
    for(k=0;k<hm[cur].size;k++)
    {
        decode(code,M,hm[cur].state[k]);
        prs(code,M,seq);
        left=code[j-1];
        up=code[j];
        if(left&&up)//11  -> 00
        {
            if (left==1&&up==1) {
                code[j-1]=code[j]=0;
                code[seq[j]]=1;
                if(j==M)shift(code,M);
                hm[cur^1].push(encode(code,M),hm[cur].f[k]);
            }
            if (left==1&&up==2) if (i==ex&&j==ey){
                code[j-1]=code[j]=0;
                if(j==M)shift(code,M);
                hm[cur^1].push(encode(code,M),hm[cur].f[k]);
            }
            if (left==2&&up==1) {
                code[j-1]=code[j]=0;
                if(j==M)shift(code,M);
                hm[cur^1].push(encode(code,M),hm[cur].f[k]);
            }
            if (left==2&&up==2) {
                code[j-1]=code[j]=0;
                code[seq[j-1]]=2;
                if(j==M)shift(code,M);
                hm[cur^1].push(encode(code,M),hm[cur].f[k]);
            }
        }
        else if(left+up)
        {
            if(maze[i][j+1])
            {
                code[j-1]=0;
                code[j]=left|up;
                hm[cur^1].push(encode(code,M),hm[cur].f[k]);
            }
            if(maze[i+1][j])
            {
                code[j-1]=left|up;
                code[j]=0;
                if(j==M)shift(code,M);
                hm[cur^1].push(encode(code,M),hm[cur].f[k]);
            }
        }
        else
        {
            if(maze[i][j+1]&&maze[i+1][j])
            {
                code[j-1]=1,code[j]=2;
                hm[cur^1].push(encode(code,M),hm[cur].f[k]);
            }
        }
    }
}

void dpblock(int i,int j,int cur)
{
    int k;
    for(k=0;k<hm[cur].size;k++)
    {
        decode(code,M,hm[cur].state[k]);
        code[j-1]=code[j]=0;
        if(j==M)shift(code,M);
        hm[cur^1].push(encode(code,M),hm[cur].f[k]);
    }
}

void solve()
{
    bool fl=0;
    For(i,N) For(j,M) if (maze[i][j]) fl=1,ex=i,ey=j;
    if(!fl) {
        puts("0");return;
    }

    int i,j,cur=0;
    ll ans=0;
    hm[cur].init();
    hm[cur].push(0,1);
    for(i=1;i<=N;i++)
      for(j=1;j<=M;j++)
      {
          hm[cur^1].init();
          if(maze[i][j])dpblank(i,j,cur);
          else dpblock(i,j,cur);
          cur^=1;
      }
    for(i=0;i<hm[cur].size;i++)
      ans+=(hm[cur].state[i]==0)*hm[cur].f[i];
    cout<<ans<<endl; 
}
int main()
{
//  freopen("poj1739.in","r",stdin);
    while(1) {
        init();
        if (!N) break;
        solve();
    }
    return 0;
}
nike0good
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
插头DP论文
05-27
基于连通性状态压缩的动态规划问题 长沙市雅礼中学 陈丹琦 【摘要】 基于状态压缩的动态规划问题是一类以集合信息为状态且状态总数为指数级的特殊的动态规划问题．在状态压缩的基础上，有一类问题的状态中必须要...
插头DP模板待完成.md
02-23
未完成的ＤＰ
插头DP专题
weixin_30279315的博客
06-19 48
fzu 1977 格子分三种：不能走，可走可不走，一定要走。求单回路条数。 如果左上插头都为0 并且此格子可以不走 直接将状态加入到hash表中。记录最后一个必须走的格子 此后如果有回路形成 加入到结果。有回路形成 left=1 up=2 并且其它位置要全为0 为此WA了一晚上。。 另外 若plugDP最后return dp[0] 测试数据又无解 应写成if(src->sz==0) re...
插头DP
zhangxian___的博客
07-18 652
转载自：http://blog.csdn.net/sf____/article/details/15026397 最近两周一直在刷DP题，前几天接触了插头DP。说实话，直接做“入门”题Ural 1519 Formula 1难度略大，而网上也没有个由浅入深的题表和教程。故总结了一下最近做的、适合作为插头DP专题入门题的题目，专心写一篇博客。大牛见笑。     学习插头DP前，
插头dp练习
weixin_30650859的博客
05-23 283
最近学了插头dp，准备陆续更新插头dp类练习。 学习论文还是cdq那篇《基于连通性状态压缩的动态规划问题》。 基本的想法都讲得很通透了，接下来就靠自己yy了。 还有感谢kuangbin大大的专题练习。 首先入门肯定写个n*m*state的插头dp，没为什么，这东西好写啊~ 然后你就想着，当n*m特别大的时候我该怎么解决呢（m不可能特别大，因为他决定了状态数state）。 你会发现这个d...
dp专题训练
weixin_30477797的博客
08-24 196
****************************************************************************************** 动态规划 专题训练 ******************************************************************************************** ...
简单插头DP的模板
11-26
传说中插头DP的模板，参考陈丹琦大牛的论文写的，这只是前面的简单部分的模板，后面的高深部分就木有了。。。
区间DP概率DP树形DP插头DP
09-05
区间DP概率DP树形DP插头DP，每种DP一道典型例题，有助于初学者
Codeforces Round #350 (Div. 2) 题解
nike0good |Oier&ACMer | 熟能生巧
05-07 3178
Holidays Game of Robots Cinema Magic Powder - 12 Correct Bracket Sequence Editor Restore a Number Holidays#include<bits/stdc++.h> using namespace std; #define For(i,n) for(int i=1;i<=n;i++) #define For
几何算法专题
nike0good |Oier&ACMer | 熟能生巧
07-02 2603
UVA 10652 Board Wrapping UVA 11168 Airport UVA 1396 Most Distant Point from the Sea UVA 1298 Triathlon UVA 1475 Jungle OutpostUVA 10652 Board Wrapping#include<bits/stdc++.h> using namespace std; #defin
hihoCoder挑战赛20 题解
nike0good |Oier&ACMer | 熟能生巧
05-06 2505
打折机票静态区间最大值SB题#include<bits/stdc++.h> using namespace std; #define For(i,n) for(int i=1;i<=n;i++) #define Fork(i,k,n) for(int i=k;i<=n;i++) #define Rep(i,n) for(int i=0;i<n;i++) #define ForD(i,n) for(i
几何基础专题
nike0good |Oier&ACMer | 熟能生巧
06-29 2148
UVA 11437 Triangle Fun UVA 11800 Determine the Shape 四边形判定 UVA 11646 Athletics Track UVA 11817 Tunnelling the Earth 球面距离 UVA 1473 Dome of Circus UVA 11524 InCircle UVA 11731 Ex-circles 旁切圆 UVA 12300 Sm
ICPC Camp 2016 几道神奇的构造打表题
nike0good |Oier&ACMer | 熟能生巧
02-22 1553
SJTU Dreadnought Contest The Magic Square The Kirakira Cycle XOR Tree Moscow SU Trinity Contest Green DaySJTU Dreadnought ContestThe Magic Square题意：已知n≤100n\le 100, 你需要用n个边长为整数的正方形凑出一个大正方形，无解输出“Impossi
April Fools Day Contest 2016 题解
nike0good |Oier&ACMer | 熟能生巧
04-02 1549
April Fools Day Contest 2016 题解
# museum(Gauss-Jordan/Gauss对比-4倍常数)
nike0good |Oier&ACMer | 熟能生巧
05-04 1352
【题一】博物馆(museum .cpp/c/pas) 厦门一中  刘定峰 输入文件名：museum.in 输出文件名：museum.out源程序文件名：museum.c/cpp/pas 时间限制：4s 内存限制：128MB              ［题目描述］ 　　有一天Petya和他的朋友Vasya在进行他们众多旅行中的一次旅行，他们决定去参观一座城堡博物馆。这座博物馆有着特别的样
# NOJ 2015年陕西省程序设计竞赛网络预赛（正式赛）(落后的小岛-最小生成树-并查集迭代路径优化与不优化对比)[Hobo]
nike0good |Oier&ACMer | 熟能生巧
05-16 1198
G - 落后的小岛 Time Limit: 3000 ms        Memory Limit: 10240 KB Submit Description 在某片海域分布着n座小岛，每个小岛的位置用一对整数(x, y)表示。但是小岛上的条件十分落后，人们只能划船到其他岛，这非常不方便。有一天，智慧与勇气并存的温温来到了这片海域，她决定帮助居民在小岛之间
BZOJ 4747-4749题解 Usaco2016 Dec
nike0good |Oier&ACMer | 熟能生巧
03-03 1151
BZOJ 4747: [Usaco2016 Dec]Counting Haybales给出N（1≤N≤100,000）个数，和 Q（1≤Q≤100,000）个询问。每个询问包含两个整数A,B(0≤A≤B≤1,000,00 0,000）。对于每个询问，给出数值在A到B间的数有多少个（包含A与B）。 暴力#include<bits/stdc++.h> using namespace std;
NOIP进阶：插头DP策略与连通性状态压缩解析
"该资源是针对NOIP基础学习的课件，主要讲解了插头DP这一动态规划策略，由金牌选手制作，适用于准备NOIP竞赛的学习者。" 在动态规划领域，插头DP是一种有效的方法，尤其适用于处理具有连通性特征的问题。此课件由...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值