Pandora adventure FZU1977

最新推荐文章于 2017-09-05 11:41:00 发布
最新推荐文章于 2017-09-05 11:41:00 发布
阅读量674 收藏
点赞数
分类专栏： 动态规划 插头DP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gyarenas/article/details/9306259
版权

这题属于不必走完所有格子的一条回路问题，参考别人的思路，加了一个是否形成环的状态位，但效率好低啊，不知道括号表示法对这种问题效率如何。


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <algorithm>
#include <vector>
#include <cstring>
#include <stack>
#include <cctype>
#include <utility>   
#include <map>
#include <string>  
#include <climits> 
#include <set>
#include <string>    
#include <sstream>
#include <utility>   
#include <ctime>

using std::priority_queue;
using std::vector;
using std::swap;
using std::stack;
using std::sort;
using std::max;
using std::min;
using std::pair;
using std::map;
using std::string;
using std::cin;
using std::cout;
using std::set;
using std::queue;
using std::string;
using std::istringstream;
using std::make_pair;
using std::getline;
using std::greater;
using std::endl;
using std::multimap;
using std::deque;

typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int, int> PAIR;
typedef multimap<int, int> MMAP;

const int MAXN(100010);
const int MAXM(10010);
const int MAXE(10010);
const int HSIZE(13131);
const int SIGMA_SIZE(26);
const int MAXH(19);
const int INFI((INT_MAX-1) >> 1);
const int MOD(7777777);
const ULL BASE(31);
const LL LIM(10000000);
const int INV(-10000);

void checkmax(int &op1, int op2) {if(op2 > op1) op1 = op2;}

struct HASH_MAP
{
	int first[HSIZE], next[MAXN];
	LL value[MAXN];
	LL state[MAXN];
	int  size;
	void init()
	{
		memset(first, -1, sizeof(first));
		size = 0;
	}

	void insert(LL ts, LL tv)
	{
		int h = ts%HSIZE;
		for(int i = first[h]; ~i; i = next[i])
			if(state[i] == ts)
			{
				value[i] += tv;
				return;
			}
		value[size] = tv;
		state[size] = ts;
		next[size] = first[h];
		first[h] = size++;
	}
}hm[2];

HASH_MAP *cur, *last;

int code[13];
int Num[9];
int N, M;
char mp[15][15];
int circuit;
bool can;


void decode(LL ts)
{
	for(int i = 0; i <= M; ++i)
	{
		code[i] = ts&7;
		ts >>= 3;
	}
	circuit = ts;
}

LL encode()
{
	LL ret = 0;
	int cnt = 0;
	ret = circuit;
	memset(Num, -1, sizeof(Num));
	for(int i = M; i >= 0; --i)
		if(code[i] == 0)
			ret <<= 3;
		else
		{
			if(Num[code[i]] < 0) Num[code[i]] = ++cnt;
			ret = (ret << 3)|Num[code[i]];
		}
	return ret;
}

int lx, ly;
bool lastgrid(int x, int y) {return x == lx && y == ly;}

void updata(int x, int y, LL tv)
{
	int up = (x == 0)? 0: code[y+1];
	int left = (y == 0)? 0: code[y];
	if(mp[x][y] == 'X')
	{
		if(up == 0 && left == 0)
		{
			code[y] = code[y+1] = 0;
			cur->insert(encode(), tv);
		}
		return;
	}
	if(mp[x][y] == 'O')
	{
		if(lastgrid(x, y)) can = true;
		if(up == 0 && left == 0)
		{
			if(x == N-1 || y == M-1) return;
			code[y] = code[y+1] = 7;
			cur->insert(encode(), tv);
		}
		else
			if(up == 0 || left == 0)
			{
				if(x != N-1)
				{
					code[y] = up+left;
					code[y+1] = 0;
					cur->insert(encode(), tv);
				}
				if(y != M-1)
				{
					code[y] = 0;
					code[y+1] = up+left;
					cur->insert(encode(), tv);
				}
			}
			else
				if(left != up)
				{
					for(int i = 0; i <= M; ++i)
						if(code[i] == up) code[i] = left;
					code[y] = code[y+1] = 0;
					cur->insert(encode(), tv);
				}
				else
					if(can)
					{
						code[y] = code[y+1] = 0;
						circuit = 1;
						cur->insert(encode(), tv);
					}
		return;
	}
	if(up == 0 && left == 0)
	{
		code[y] = code[y+1] = 0;
		cur->insert(encode(), tv);
		if(x == N-1 || y == M-1 || circuit) return;
		code[y] = code[y+1] = 7;
		cur->insert(encode(), tv);
	}
	else
		if(up == 0 || left == 0)
		{
			if(circuit) return;
			if(x != N-1)
			{
				code[y] = up+left;
				code[y+1] = 0;
				cur->insert(encode(), tv);
			}
			if(y != M-1)
			{
				code[y] = 0;
				code[y+1] = up+left;
				cur->insert(encode(), tv);
			}
		}
		else
			if(up != left)
			{
				if(circuit) return;
				for(int i = 0; i <= M; ++i)
					if(code[i] == up) code[i] = left;
				code[y] = code[y+1] = 0;
				cur->insert(encode(), tv);
			}
			else
				if(can)
				{
					if(circuit) return;
					code[y] = code[y+1] = 0;
					circuit = 1;
					cur->insert(encode(), tv);
				}
}

void solve()
{
	cur = hm;
	last = hm+1;
	last->init();
	last->insert(0, 1);
	can = false;
	for(int i = 0; i < N; ++i)
		for(int j = 0; j < M; ++j)
		{
			cur->init();
			int sz = last->size;
			for(int k = 0; k < sz; ++k)
			{
				decode(last->state[k]);
				if(j == 0)
					for(int k2 = M; k2 >= 1; --k2)
						code[k2] = code[k2-1];
				updata(i, j, last->value[k]);
			}
			swap(cur, last);
		}
	LL ans = 0;
	int temp = 3*(M+1);
	for(int i = 0; i < last->size; ++i)
		if(((1LL << temp)&last->state[i]) != 0 && (((1LL << temp)-1)&last->state[i]) == 0)
		{
			ans = last->value[i];
			break;
		}
	printf("%I64d\n", ans);
}

int main()
{
	int TC, n_case(0);
	scanf("%d", &TC);
	while(TC--)
	{
		scanf("%d%d", &N, &M);
		for(int i = 0; i < N; ++i)
			scanf("%s", mp[i]);
		lx = -1;
		ly = -1;
		for(int i = N-1; i >= 0 && lx == -1; --i)
			for(int j = M-1; j >= 0; --j)
				if(mp[i][j] == 'O')
				{
					lx = i;
					ly = j;
					break;
				}
		printf("Case %d: ", ++n_case);
		solve();
	}
	return 0; 
}

括号表示法解决回路问题的确比最小表示法效率高。

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <algorithm>
#include <vector>
#include <cstring>
#include <stack>
#include <cctype>
#include <utility>   
#include <map>
#include <string>  
#include <climits> 
#include <set>
#include <string>    
#include <sstream>
#include <utility>   
#include <ctime>

using std::priority_queue;
using std::vector;
using std::swap;
using std::stack;
using std::sort;
using std::max;
using std::min;
using std::pair;
using std::map;
using std::string;
using std::cin;
using std::cout;
using std::set;
using std::queue;
using std::string;
using std::istringstream;
using std::make_pair;
using std::getline;
using std::greater;
using std::endl;
using std::multimap;
using std::deque;

typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int, int> PAIR;
typedef multimap<int, int> MMAP;

const int MAXN(200010);
const int MAXM(5010);
const int MAXE(10010);
const int HSIZE(13131);
const int SIGMA_SIZE(26);
const int MAXH(19);
const int INFI((INT_MAX-1) >> 1);
const int MOD(123456791);
const ULL BASE(31);
const LL LIM(10000000);
const int INV(-10000);

int N, M;
char mp[15][15];

struct HASH_MAP
{
	int first[HSIZE];
	int next[MAXN], state[MAXN];
	LL value[MAXN];
	int size;
	void init()
	{
		memset(first, -1, sizeof(first));
		size = 0;
	}
	void insert(int ts, LL tv)
	{
		int h = ts%HSIZE;
		for(int i = first[h]; ~i; i = next[i])
			if(state[i] == ts)
			{
				value[i] += tv;
				return;
			}
		value[size] = tv;
		state[size] = ts;
		next[size] = first[h];
		first[h] = size++;
	}
} hm[2];

HASH_MAP *cur, *last;
int acc[4] = {0, -1, 1, 0};  //无插头，左括号，右括号

inline int getB(int ts, int i){ return (ts >> (i << 1))&3;}  //获得指定位
inline int getLB(int ts, int i)   //通过右括号找到左括号
{
	int ret = i, cnt = 1;
	while(cnt)
	{
		--ret;
		cnt += acc[getB(ts, ret)];
	}
	return ret;
}

inline int getRB(int ts, int i)  //通过左括号找到右括号
{
	int ret = i, cnt = -1;
	while(cnt)
	{
		++ret;
		cnt += acc[getB(ts, ret)];
	}
	return ret;
}

inline void setB(int &ts, int i, int tv){ts = (ts&~(3 << (i << 1)))|(tv << (i << 1));}  //设置指定位

int CIR;
inline int getCIR(int ts) {return (ts&CIR)? 1: 0;}
inline void setCIR(int &ts, int tv) {ts = (ts&~CIR)|(tv? CIR: 0);}

void updata(int x, int y, int ts, LL tv)
{
	int left = (y == 0)? 0: getB(ts, y);
	int up = (x == 0)? 0: getB(ts, y+1);
	int circuit = getCIR(ts);
	int tts;
	if(mp[x][y] == 'X')
	{
		if(left == 0 && up == 0)
		{
			tts = ts;
			setB(tts, y, 0);
			setB(tts, y+1, 0);
			cur->insert(tts, tv);
		}
		return;
	}
	if(left == 0 && up == 0)
	{
		if(mp[x][y] != 'O')
		{
			tts = ts;
			setB(tts, y, 0);
			setB(tts, y+1, 0);
			cur->insert(tts, tv);
		}
		if(x == N-1 || y == M-1 || (mp[x][y] == 'O' && circuit)) return;
		tts = ts;
		setB(tts, y, 1);
		setB(tts, y+1, 2);
		cur->insert(tts, tv);
	}
	else
		if(left == 0 || up == 0)
		{
			if(circuit) return;
			if(x < N-1)
			{
				tts = ts;
				setB(tts, y, up+left);
				setB(tts, y+1, 0);
				cur->insert(tts, tv);
			}
			if(y < M-1)
			{
				tts = ts;
				setB(tts, y, 0);
				setB(tts, y+1, up+left);
				cur->insert(tts, tv);
			}
		}
		else
		{
			if(circuit) return;
			tts = ts;
			setB(tts, y, 0);
			setB(tts, y+1, 0);
			if(left == 1 && up == 1)
			{
				setB(tts, getRB(ts, y+1), 1);
				cur->insert(tts, tv);
			}
			else if(left == 1 && up == 2)
			{
				setCIR(tts, 1);
				cur->insert(tts, tv);
			}
			else if(left == 2 && up == 1)
			{
				cur->insert(tts, tv);
			}
			else if(left == 2 && up == 2)
			{
				setB(tts, getLB(ts, y), 2);
				cur->insert(tts, tv);
			}
		}
}

template<typename T>
void debug(const T &temp)
{
	cout << temp << endl;
}

void solve()
{
	CIR = (1 << ((M+1) << 1));
//	debug(CIR);
	cur = hm;
	last = hm+1;
	last->init();
	last->insert(0, 1);
	for(int i = 0; i < N; ++i)
	{
		int sz = last->size;
		for(int k = 0; k < sz; ++k)
			last->state[k] = ((last->state[k] << 2)&(CIR-1))|(getCIR(last->state[k])? CIR: 0);
		for(int j = 0; j < M; ++j)
		{
			cur->init();
			sz = last->size;
			for(int k = 0; k < sz; ++k)
				updata(i, j, last->state[k], last->value[k]);
			swap(cur, last);
		}
	}
	LL ans = 0;
	for(int i = 0; i < last->size; ++i)
		if(last->state[i] == CIR)
		{
			ans = last->value[i];
			break;
		}
	printf("%I64d\n", ans);
}

int main()
{
	int TC, n_case(0);
	scanf("%d", &TC);
	while(TC--)
	{
		scanf("%d%d", &N, &M);
		for(int i = 0; i < N; ++i)
			scanf("%s", mp[i]);
		printf("Case %d: ", ++n_case);
		solve();
	}
	return 0;
}


gyarenas
关注
专栏目录
fzu 1977 Pandora adventure
java开发指南博客 【转载】
05-03 99
题目链接：http://acm.fzu.edu.cn/problem.php?pid=1977 题目大意及思路：简单回路数问题，不过有必走点和非必走点之分，做法是在要新加一个括号时判断是否必走，如果不是必走，则可不加括号，还有就是在经过最后一个必走点后，只要存在简单回路就加入ans。 #include&lt;stdio.h&gt; #include&lt;string.h&gt; #def...
FZU 1977 Pandora adventure
DS-K的博客
11-06 427
题目链接：http://acm.fzu.edu.cn/problem.php?pid=1977 题意：地图上有三种点，不可走点，必须走的点，可走可不走的点。问有多少种单回路，可以经过所以的必须走的点。 思路：插头dp，分三种类型格子讨论转移。由于回路的终点不固定，所以先记录最后一个可行格子的坐标，如果当前位置不小于最后一个可行格子，且合并相同连通性的格子形成单回路，我们就累加方
FZU 1977 Pandora adventure
imut zcy,I promise You.
05-13 482
单回路数，有三种格子， 1.必须走 2.可以走 3.不可以走 求回路数
fzu1977-Pandora Adventure
dengtan9179的博客
09-05 116
题意 \(n\times m\) 的棋盘，有一些格子必须走，有一些必须不走，有一些可走可不走，求合法单回路个数。 \(n,m\le 12\) 。 分析 这题相比之前那题，多了一个可走可不走到条件，也就是说，终点不再一定是最后一个必经点。这题有两种做法。网上大部分到做法是在状态后面加一个 isend 参数，若形成回路就继续推下去，遇到新插头就说明不合法，直到推到最后一个。 我的方法比较简单...
FZU 1977 Pandora adventure（插头DP）
记录成长的点点滴滴. . . . .
07-26 961
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
pandora-apidoc：pandora.com API文档
02-04
《Pandora API 文档深度解析》 在数字化时代，API（Application Programming Interface）成为了连接不同服务、系统和应用的核心工具。Pandora.com，一个知名的音乐流媒体平台，也提供了其API，允许开发者构建与...
迅雷下载宝breed不死固件和PandoraBox固件
10-20
在本文中，我们将主要探讨两个重要的固件类型——Breed不死固件和PandoraBox固件，以及如何为迅雷下载宝安装这些固件。 1. **Breed不死固件**： Breed是一款知名的开源路由器固件，以其稳定性和易用性而受到用户...
Python-魔改Pandora源码，GitHUB上的Pandora
最新发布
09-21
魔改的pandora源码： 1.增加了Windows下的启动脚本。引好依赖，可以使用脚本启动。 2.启动pandora 命令模式启动，需要过Login页面才能使用，不能直接使用。 3.pandora 命令模式下，需要在‘pandora-master\src\...
newifi y1稳定挂卡PandoraBox
09-01
PandoraBox-ralink-mt7620-y1-squashfs-sysupgrade-r1012-20150606
PandoraBox-ralink-mt7620-xiaomi-mini-squashfs-sysupgrade-r1696-20151122
04-25
潘多拉路由器固件r1024，r1696版本是带多拨最稳定的！r1696版本可以说是一个神版本，可以说是潘多拉的顶峰！但是现在基本上找不到资源，潘多拉官网根本找不到r1696的版本
foj 1977 Pandora adventure(插头DP)
马德里小铁匠的铁匠铺
04-20 686
哎。。。。。 都是泪。。。。。 这游戏太难了。。。。 再一次写了三天才AC。。。 生活为什么要这么艰难。。。。
FZU 1977 Pandora adventure （插头DP，常规）
weixin_30411997的博客
09-07 94
题意：有一个n*m矩阵，其中有些格子必走，有些格子不可走，其他格子是可走也可不走，问有多少条哈密顿回路？ 思路： 　　本来是一道很简单的题，代码写多了连白痴bug都查不出了，竟然用i>=ex&&j>=ey来判定最后一个必走点后面的点！明显是错的。 　　其实主要在选走的格子，那么有两种选择，“走”or“不走”，不走的话上一个格子的状态照搬过来。这样...
fzu 1977 Pandora adventure（插头DP一条回路 格子的占用或不占用）
志当存高远
10-01 1238
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 549
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".
郑厂长系列故事——新闻净化 hdu4534
霁月难逢 彩云易散
06-02 2191
AC自动机+DP， 此题有俩个优化目标：最少字母使文章符合要求，并让加成分之和尽可能高，可以把俩个目标合并成一个，即让删除一个字母所获得的加分为一个很小的值(此题可以取-200000)，这样优化的目标即变为是的加分最大，最后再把结果分离即可。 #include #include #include #include #include #include #include #in
生成树计数 NOI2007
霁月难逢 彩云易散
07-23 1654
这题一定要把状态认识清楚，因为只选最后K个点的连通性作为状态，所以一个状态可能会对应很多的连边的情况，由于无法找到特殊的状态吧初始情况地推出来，所以初始情况需要暴力求解，然后再用矩阵加速。 #include #include #include #include #include #include #include #include #include #include
Resource Archiver hdu3247
霁月难逢 彩云易散
05-23 1631
通过这题加深了对trie图的认识，trie图建好之后，匹配就不再需要fail指针了，在解决生成串类问题中，由于有禁止的包含的串，一定不能用fail指针进行转移，否则生成的串中有可能包含禁止串。  这道题关键在bfs求0点和resource串尾节点这些点俩俩之间最小距离，有俩种方法， 第一种是只通过ch来转移，但这样求出来的最短路不一定是最短的，因为有些resource串可能是另一些resour
Formula1 URAL1519
霁月难逢 彩云易散
07-09 1476
这题可以说是正式的插头dp，需要对插头标号，虽然研读了hh的模板和论文，但写起来还是花了很多时间，主要是细节方面的东西，比如第一列和最后一列需要特殊讨论，还有最后一个合法格子也需要特殊讨论 #include #include #include #include #include #include #include #include #include #include
pandora docker
07-06
Pandora Docker 是一种虚拟化技术，它能够将应用程序及其依赖项打包成一个独立的容器。这种容器可以在不同的操作系统和硬件平台上进行部署，而无需担心环境的差异性。 Pandora Docker 具有以下几个主要优点。首先，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值