foj 1977 Pandora adventure(插头DP)

最新推荐文章于 2017-09-05 11:41:00 发布
最新推荐文章于 2017-09-05 11:41:00 发布
阅读量680 收藏
点赞数
分类专栏： 动态规划 模版 文章标签： 动态规划 dp 插头DP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hzh_0000/article/details/24174049
版权
动态规划 同时被 3 个专栏收录
296 篇文章 0 订阅
订阅专栏
模版
21 篇文章 0 订阅
订阅专栏
插头DP
7 篇文章 0 订阅
订阅专栏

哎。。。。。哭

都是泪。。。。。哭

这游戏太难了。。。。哭

再一次写了三天才AC。。。哭

生活为什么要这么艰难。。。。哭




妈蛋的啊。。。。

经过这一题之后我对插头DP理解更深了。。。。。只要是形成回路之后就不用再添加到装态里去了。。。。。。。

这次的代码也比前几次漂亮了不少，

当然是因为借鉴了别人的写法

AC代码如下：

四进制

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const __int64 digit[15] = { 1, 3, 9, 27, 81, 243, 729, 2187, 6561, 19683, 59049, 177147, 531441, 1594323, 4782969 };

const int mod = 10007;

struct HASHS{
    __int64 statu[80010], cnt[80010];
    int head[mod+10], next[80010], E;

    int findhash( __int64 st ){
        return st % mod;
    }

    void init(){
        E = 0;
        memset( head, -1, sizeof( head ) );
    }

    void add( __int64 st, __int64 num ){
        int u = findhash( st );
        for( int i = head[u]; i != -1; i = next[i] ){
            if( statu[i] == st ){
                cnt[i] += num;
                return;
            }
        }
        statu[E] = st;
        cnt[E] = num;
        next[E] = head[u];
        head[u] = E++;
    }
}biao[2];

int N, M;
char s[16][16];

int get( __int64 S,int p,int l=2)
{
	return (S>>(p*l))&((1<<l)-1);
}

void set( __int64 &S,int p,int v,int l=2)
{
	S^=get(S,p,l)<<(p*l);
	S^=(v&((1<<l)-1))<<(p*l);
}

int find_r( int st, int j ){
    int temp = 0, l;
    for( l = j + 1; l <= M; l++ ){
        __int64 ttt = get( st, l );
        if( ttt == 2 ){
            if( temp == 0 ){
                break;
            }else{
                temp--;
            }
        }else if( ttt == 1 ){
            temp++;
        }
    }
    return l;
}

int find_l( int st, int j ){
    int temp = 0, l;
    for( l = j - 1; l >= 0; l-- ){
        __int64 ttt = get( st, l );
        if( ttt == 1 ){
            if( temp == 0 ){
                break;
            }else{
                temp--;
            }
        }else if( ttt == 2 ){
            temp++;
        }
    }
    return l;
}


__int64 solve(){
    int now;
    now = 1;
	int lasti, lastj;
	lasti = -1;
	lastj = 1;
	int flag = 1;
	for( int i = N; i >= 1 && flag; i-- ){
		for( int j = M; j >= 1 && flag; j-- ){
			if( s[i][j] == 'O' ){
				lasti = i;
				lastj = j;
				flag = 0;
			}
		}
	}
	__int64 ans = 0;
    biao[0].init();
    biao[1].init();
    biao[1].add( 0, 1 );
    now = 0;
    for( int i = 1; i <= N; i++ ){
        now ^= 1;
        biao[now^1].init();
        for( int k = 0; k < biao[now].E; k++ ){
            __int64 st = biao[now].statu[k];
			__int64 sum = biao[now].cnt[k];
            biao[now^1].add( st << 2, sum );
        }
        for( int j = 0; j < M; j++ ){
            now ^= 1;
            biao[now^1].init();
            for( int k = 0; k < biao[now].E; k++ ){

                __int64 st = biao[now].statu[k];
                __int64 sum = biao[now].cnt[k];
                __int64 numj = get( st, j );
                __int64 numj_1 = get( st, j + 1 );

                if( s[i][j+1] == 'O' || s[i][j+1] == '*' ){
                    if( numj == 0 && numj_1 == 0 ){
                        if( s[i][j+1] == '*' )  biao[now^1].add( st, sum );
                        set( st, j, 1 );
                        set( st, j + 1, 2 );
                        if( j + 1 < M && s[i+1][j+1] != 'X' && s[i][j+2] != 'X' ) biao[now^1].add( st, sum );
                    }else if( numj == 0 || numj_1 == 0 ){
                        set( st, j, 0 );
                        set( st, j + 1, numj + numj_1 );
                        if( j + 1 < M && s[i][j+2] != 'X' ) biao[now^1].add( st, sum );
                        set( st, j, numj + numj_1 );
                        set( st, j + 1, 0 );
                        if( s[i+1][j+1] != 'X' ) biao[now^1].add( st, sum );
                    }else{
                        if( numj == 1 && numj_1 == 1 ){
                            int l = find_r( st, j + 1 );
                            if( l <= M ){
                                set( st, l, 1 );
                                set( st, j, 0 );
                                set( st, j + 1, 0 );
                                biao[now^1].add( st, sum );
                            }
                        }else if( numj == 2 && numj_1 == 2 ){
                            int l = find_l( st, j );
                            if( l >= 0 ){
                                set( st, l, 2 );
                                set( st, j, 0 );
                                set( st, j + 1, 0 );
                                biao[now^1].add( st, sum );
                            }
                        }else if( numj == 2 && numj_1 == 1 ){
                            set( st, j, 0 );
                            set( st, j + 1, 0 );
                            biao[now^1].add( st, sum );
                        }else{
                            set( st, j, 0 );
                            set( st, j + 1, 0 );
                            if( ( i > lasti || ( i == lasti && j + 1 >= lastj ) ) && !st ){
                                ans += sum;
                            }
                        }
                    }

                }else{
                    if( numj == 0 && numj_1 == 0 ){
                        biao[now^1].add( st, sum );
                    }
                }
            }
        }
    }
    return ans;
}

int main(){
    int T, Case = 1;
    cin >> T;
    while( T-- ){
        scanf( "%d%d", &N, &M );
		memset( s, 0, sizeof( s ) );
        for( int i = 1; i <= N; i++ ){
            scanf( "%s", &s[i][1] );
        }
        printf( "Case %d: %I64d\n", Case++, solve() );
    }
    return 0;
}

三进制

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const __int64 digit[15] = { 1, 3, 9, 27, 81, 243, 729, 2187, 6561, 19683, 59049, 177147, 531441, 1594323, 4782969 };

const int mod = 10007;

struct HASHS{
    __int64 statu[80010], cnt[80010];
    int head[mod+10], next[80010], E;

    int findhash( __int64 st ){
        return st % mod;
    }

    void init(){
        E = 0;
        memset( head, -1, sizeof( head ) );
    }

    void add( __int64 st, __int64 num ){
        int u = findhash( st );
        for( int i = head[u]; i != -1; i = next[i] ){
            if( statu[i] == st ){
                cnt[i] += num;
                return;
            }
        }
        statu[E] = st;
        cnt[E] = num;
        next[E] = head[u];
        head[u] = E++;
    }
}biao[2];

int N, M;
char s[16][16];

int get( int k, int st ){
    return ( st % digit[k+1] ) / digit[k];
}

int find_r( int st, int j ){
    int temp = 0, l;
    for( l = j + 1; l <= M; l++ ){
        __int64 ttt = ( st % digit[l+1] ) / digit[l];
        if( ttt == 2 ){
            if( temp == 0 ){
                break;
            }else{
                temp--;
            }
        }else if( ttt == 1 ){
            temp++;
        }
    }
    return l;
}

int find_l( int st, int j ){
    int temp = 0, l;
    for( l = j - 1; l >= 0; l-- ){
        __int64 ttt = ( st % digit[l+1] ) / digit[l];
        if( ttt == 1 ){
            if( temp == 0 ){
                break;
            }else{
                temp--;
            }
        }else if( ttt == 2 ){
            temp++;
        }
    }
    return l;
}

__int64 solve(){
	int now;
	int lasti, lastj;
	lasti = -1;
	lastj = 1;
	int flag = 1;
	for( int i = N; i >= 1 && flag; i-- ){
		for( int j = M; j >= 1 && flag; j-- ){
			if( s[i][j] == 'O' ){
				lasti = i;
				lastj = j;
				flag = 0;
			}
		}
	}
	__int64 ans = 0;
//	if( lasti == -1 ){
 //       ans += 1;
//	}
	biao[0].init();
    biao[1].init();
    biao[1].add( 0, 1 );
    now = 0;
    for( int i = 1; i <= N; i++ ){
        now ^= 1;
        biao[now^1].init();
        for( int k = 0; k < biao[now].E; k++ ){
            __int64 st = biao[now].statu[k];
			__int64 sum = biao[now].cnt[k];
            biao[now^1].add( st * 3, sum );
        }
        for( int j = 0; j < M; j++ ){
            now ^= 1;
            biao[now^1].init();
            for( int k = 0; k < biao[now].E; k++ ){

                __int64 st = biao[now].statu[k];
                __int64 sum = biao[now].cnt[k];
                __int64 numj = ( st % digit[j+1] ) / digit[j];
                __int64 numj_1 = ( st % digit[j+2] ) / digit[j+1];
          //      __int64 tt = ( st % digit[M+2] ) / digit[M+1];
                __int64 newt;

                if( s[i][j+1] == 'O' || s[i][j+1] == '*' ){

                    if( numj == 0 && numj_1 == 0 ){
                        newt = st + digit[j] * ( 1 - numj ) + digit[j+1] * ( 2 - numj_1 );
                        if( j + 1 < M && s[i+1][j+1] != 'X' && s[i][j+2] != 'X' ) biao[now^1].add( newt, sum );
                        if( s[i][j+1] == '*' )  biao[now^1].add( st, sum );
                    }else if( numj == 0 || numj_1 == 0 ){
                        newt = st + digit[j] * ( 0 - numj ) + digit[j+1] * ( numj + numj_1 - numj_1 );
                        if( j + 1 < M && s[i][j+2] != 'X' ) biao[now^1].add( newt, sum );
                        newt = st + digit[j] * ( numj + numj_1 - numj ) + digit[j+1] * ( 0 - numj_1 );
                        if( s[i+1][j+1] != 'X' ) biao[now^1].add( newt, sum );
                    }else{
                        if( numj == 1 && numj_1 == 1 ){
                            int l = find_r( st, j + 1 );
                            if( l <= M ){
                                newt = st + digit[l] * ( 1 - 2 ) - digit[j] * numj - digit[j+1] * numj_1;
                                biao[now^1].add( newt, sum );
                            }
                        }else if( numj == 2 && numj_1 == 2 ){
                            int l = find_l( st, j );
                            if( l >= 0 ){
                                newt = st + digit[l] * ( 2 - 1 ) - digit[j] * numj - digit[j+1] * numj_1;
                                biao[now^1].add( newt, sum );
                            }
                        }else if( numj == 2 && numj_1 == 1 ){
                            newt = st - digit[j] * numj - digit[j+1] * numj_1;
                            biao[now^1].add( newt, sum );
                        }else{
                           // if( tt == 0 ){
                                newt = st - digit[j] * numj - digit[j+1] * numj_1;
								if( ( i > lasti || ( i == lasti && j + 1 >= lastj ) ) && !newt ){
	                                ans += sum;
								}
                        //    }
                        }
                    }

                }else{
                    if( numj == 0 && numj_1 == 0 ){
                        biao[now^1].add( st, sum );
                    }
                }
            }
        }
    }
    return ans;
}

int main(){
    int T, Case = 1;
    cin >> T;
    while( T-- ){
        scanf( "%d%d", &N, &M );
		memset( s, 0, sizeof( s ) );
        for( int i = 1; i <= N; i++ ){
            scanf( "%s", &s[i][1] );
        }
        printf( "Case %d: %I64d\n", Case++, solve() );
    }
    return 0;
}

/*

100

3 3
**O
O**
*O*

12 12
OOOOOOOOOOOO
OOOOOOOOOOOO
OOOOOOOOOOOO
OOOOOOOOOOOO
OOOOOOOOOOOO
OOOOOOOOOOOO
OOOOOOOOOOOO
OOOOOOOOOOOO
OOOOOOOOOOOO
OOOOOOOOOOOO
OOOOOOOOOOOO
OOOOOOOOOOOO

4 4
XXOO
OOOO
OOOO
OOOO

4 4
OOOO
OOOO
OOOO
OOOO
*/


team79
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
FOj部分水题AC答案
04-18
"FOj部分水题AC答案"这个标题表明这是一组来自FOj（可能是某个在线编程竞赛平台的简称）的简单问题，其中部分问题已经得到了正确的解答（AC是Accepted的缩写，表示程序通过了所有测试用例）。 在描述中提到"代Un的...
FOJ（大部分标程） ACM
12-26
标题 "FOJ（大部分标程） ACM" 指的是一个与ACM国际大学生程序设计竞赛（ACM International Collegiate Programming Contest, ICPC）相关的资源集合，其中FOJ（可能是"Full Option Judge"的缩写）是用于练习和提交...
fzu 1977 Pandora adventure
java开发指南博客 【转载】
05-03 95
题目链接：http://acm.fzu.edu.cn/problem.php?pid=1977 题目大意及思路：简单回路数问题，不过有必走点和非必走点之分，做法是在要新加一个括号时判断是否必走，如果不是必走，则可不加括号，还有就是在经过最后一个必走点后，只要存在简单回路就加入ans。 #include&lt;stdio.h&gt; #include&lt;string.h&gt; #def...
Pandora adventure FZU1977
霁月难逢 彩云易散
07-12 670
这题属于不必走完所有格子的一条回路问题，参考别人的思路，加了一个是否形成环的状态位，但效率好低啊，不知道括号表示法对这种问题效率如何。 #include #include #include #include #include #include #include #include #include #include #include #include #inc
FZU 1977 Pandora adventure
DS-K的博客
11-06 423
题目链接：http://acm.fzu.edu.cn/problem.php?pid=1977 题意：地图上有三种点，不可走点，必须走的点，可走可不走的点。问有多少种单回路，可以经过所以的必须走的点。 思路：插头dp，分三种类型格子讨论转移。由于回路的终点不固定，所以先记录最后一个可行格子的坐标，如果当前位置不小于最后一个可行格子，且合并相同连通性的格子形成单回路，我们就累加方
FZU 1977 Pandora adventure
imut zcy,I promise You.
05-13 475
单回路数，有三种格子， 1.必须走 2.可以走 3.不可以走 求回路数
fzu1977-Pandora Adventure
dengtan9179的博客
09-05 110
题意 \(n\times m\) 的棋盘，有一些格子必须走，有一些必须不走，有一些可走可不走，求合法单回路个数。 \(n,m\le 12\) 。 分析 这题相比之前那题，多了一个可走可不走到条件，也就是说，终点不再一定是最后一个必经点。这题有两种做法。网上大部分到做法是在状态后面加一个 isend 参数，若形成回路就继续推下去，遇到新插头就说明不合法，直到推到最后一个。 我的方法比较简单...
FOJ.1207.zip_26.2_了然foj
09-19
给定一个自然数n，由n开始可以依次产生半数集set(n)中的数如下。 (1)n∈set(n)； (2)在n的左边加上一个自然数，但该自然数不能超过最近添加的数的一半； (3)按此规则进行处理，直到不能再添加自然数为止。...
FOJ 1150 Peter's smokes
05-06
第一次上传东西... 本人是个初学者，希望大家多多指教
foj.rar_On the Line_meet62l_pick8xd_界面编程
最新发布
09-24
【标题】"foj.rar" 是一个压缩包文件，其主题是"On the Line_meet62l_pick8xd_界面编程"。这个标题暗示了它包含的代码示例可能涉及命令行界面编程，特别是与创建文件相关的快捷方式或实用工具。 【描述】描述指出这...
FZU 1977 Pandora adventure（插头DP）
记录成长的点点滴滴. . . . .
07-26 947
Problem 1977 Pandora adventure Accept: 320    Submit: 1034 Time Limit: 1000 mSec    Memory Limit : 32768 KB Problem Description The pollution of the earth is so serious that people can n
FZU 1977 Pandora adventure （插头DP，常规）
weixin_30411997的博客
09-07 90
题意：有一个n*m矩阵，其中有些格子必走，有些格子不可走，其他格子是可走也可不走，问有多少条哈密顿回路？ 思路： 　　本来是一道很简单的题，代码写多了连白痴bug都查不出了，竟然用i>=ex&&j>=ey来判定最后一个必走点后面的点！明显是错的。 　　其实主要在选走的格子，那么有两种选择，“走”or“不走”，不走的话上一个格子的状态照搬过来。这样...
fzu 1977 Pandora adventure（插头DP一条回路 格子的占用或不占用）
志当存高远
10-01 1195
Problem 1977 Pandora adventure Accept: 244    Submit: 813 Time Limit: 1000 mSec    Memory Limit : 32768 KB  Problem Description The pollution of the earth is so serious that people can not
fzu1977Pandora adventure【插头dp】
MissZhou要努力
03-12 524
roblem Description The pollution of the earth is so serious that people can not survive any more. Fortunately, people have found a new planet that maybe has life, and we call it "Pandora Planet".
poj 1738 DP(石子合并的GarsiaWachs算法)
马德里小铁匠的铁匠铺
03-09 1101
详细报告，请点这里 AC代码如下: #include #include #include #include using namespace std; int num[51000], N, ans, m; void combine( int k ){ int temp = num[k] + num[k-1]; ans += temp; m--; for
poj 1038 状态压缩dp
马德里小铁匠的铁匠铺
03-10 1037
还在调试 #include #include #include #include using namespace std; int pow[11] = { 1, 3, 9, 27, 81, 243, 729, 2187, 6561, 19683, 59049 }; int maps[160][11]; int N, M, K; int dp[2][60000]; int nowstat
快速幂取模
马德里小铁匠的铁匠铺
10-26 968
long long DFS( long long base, long long exp, long long mod ){//快速幂取模 if( exp == 0 ){ return 1 % mod; } if( exp == 1 ){ return base % mod; } long long ans = DFS( base, exp / 2, mod ) % mod;
线性时间内筛素数和欧拉函数
马德里小铁匠的铁匠铺
08-25 913
学习了下线性时间筛素数和求欧拉函数 大部分类容转自点击打开链接
数位DP
马德里小铁匠的铁匠铺
11-14 908
常用数位DP写法：   int dfs(int i, int s, bool e) { if(i==-1) return s==target_s; if(!e && ~f[i][s]) return f[i][s]; intres = 0; intu = e?num[i]:9; for(int d = first?1:0; d <= u; ++d)
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值