HDU 5743 Join The Future 给定部分区间和奇偶，和数字范围，求方案数 DP

最新推荐文章于 2020-04-21 17:42:26 发布
最新推荐文章于 2020-04-21 17:42:26 发布
阅读量503 收藏 1
点赞数
分类专栏： DP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_23081367/article/details/52214051
版权

题目大意：

给若干个（40个）数字，每个数字有一个取值范围。

给若干个区间【l,r】和flag表示奇偶

问，让[L,R]区间的数字，的数字和为奇/偶， 的方案总数


假设s[i]为前i个数字的前缀和。 对于L,R而言，就是s[r]和s[l-1]。


如果[L,R]为奇数，那么就是s[r]-s[l-1]为奇数。


我们并不十分关心s[i]是多少，只在意是奇还是偶，并且是否可行。


f[i][0/1]表示s[i]为偶/奇。


这样如果题目给了 【L,R】的话，那么s[l-1]和s[r]的奇偶关系就是关联的。


最后题目一定给出若干个连通快，连通块内的取值，决定一个值，就决定了整个连通快。

对于所有连通快，暴力一下就行了。题解大致描述的就是这样的方法


暴力后，可以知道每个s[i]的取值是任意，还是必须奇还是必须偶。这个问题DP就行了，记录方案比较麻烦。


切记： 题目可以出现一个数字的取值范围是[5,5]或者[7,7]这样的。 所以多出一些细节。


数据十分弱，不考虑也能过（网上我搜到的所有人的程序都过不了下面这组数据……2016年8月15日19:44:56  当然我能过QAQ，对拍怎么都过不了……）

1
3 2
2 5
4 4
4 6
1 2 1
1 3 1

答案无论如何，最小字典序的第二个数字也不会是5吧~？ 网上不少人程序都是错的……

因为数据弱，我也不能保证我程序就是对的。

#include <bits/stdc++.h>
#include <ext/pb_ds/priority_queue.hpp>
#include <tr1/unordered_map>
using namespace std::tr1;
using std::sort;
using std::max;
using std::cout;
using std::stack;
using std::cin;
using std::endl;
using std::swap;
using std::pair;
using std::vector;
using std::set;
using std::map;
using std::multiset;
using std::queue;
using std::greater;
using std::string;
using std::priority_queue;
using std::max_element;
using std::min_element;
using __gnu_pbds::pairing_heap_tag;
__gnu_pbds::priority_queue<int, greater<int>, pairing_heap_tag> heap;
#define Hash unordered_map
#define pr(x) cout<<#x<<" = "<<x<<" "
#define prln(x)    cout<<#x<<" = "<<x<<endl



typedef long long LL;

LL mymin(LL a, LL b)
{
	if (a>b)	return b;
	return a;
}

const int maxn = 50;
int n, m;
int low[maxn], up[maxn];
struct edge{int will,relationship;};
vector<edge>g[maxn];
int block_cnt;
int belong[maxn], block_idx[maxn];
int f[maxn];
const LL mod = 1e9+7;
const int INF = 0x3f3f3f3f;

void init()
{
	scanf("%d%d", &n, &m);
	for (int i = 1; i <= n; ++ i)
	{
		scanf("%d%d", &low[i], &up[i]);
	}
	for (int i = 0; i <= n; ++ i)    g[i].clear();
	for (int i = 1; i <= m; ++ i)
	{
		int a, b, c;
		scanf("%d%d%d", &a, &b, &c);
		--a;
		g[a].push_back({b,c});
		g[b].push_back({a,c});
	}
	memset(belong, 0, sizeof(belong));
	memset(f, -1, sizeof(f));
	block_cnt=0;
}
queue<int>q;
void bfs(int k)
{
	if (g[k].size() == 0)    return ;//孤立点
	while (!q.empty())q.pop();
	q.push(k);
	belong[k] = ++block_cnt;
	block_idx[block_cnt] = k;
	while (!q.empty())
	{
		int now = q.front();
		q.pop();
		for (auto x : g[now])
		{
			int will = x.will;
			if (belong[will])    continue;
			belong[will] = block_cnt;
			q.push(will);
		}
	}
}

bool ranse(int block, int colo)    //返回false则为无法染色
{
	int now = block_idx[block];
	for (int i = 0; i <= n; ++ i)
		if (belong[i] == block)    f[i] = -1;
	while (!q.empty())q.pop();
	q.push(now);
	f[now] = colo;
	while (!q.empty())
	{
		int now = q.front();
		q.pop();
		for (auto x : g[now])
		{
			int will = x.will;
			if (f[will] != -1 && f[will] != f[now] ^ x.relationship)    return false;
			if (f[will] == -1)
			{
				f[will] = f[now] ^ x.relationship;
				q.push(will);
			}
		}
	}
	return true;
}

int output[maxn];

LL get(int x, int flag)//flag 为0或1。  第x个数字，选0偶数，1奇数个数字，的总方案数
{
	if (low[x]%2 ==1 && up[x]%2==1)    return (up[x] - low[x]) / 2 + flag;
	if (low[x]%2  != up[x]%2)    return (up[x] - low[x] + 1) / 2;
	return (up[x] - low[x])/2 + (flag^1);
}

int getnum(int x, int flag)//得到x的最小 0偶数  1奇数
{
	if (low[x]%2 == flag)    return low[x];
	//else return low[x]+1;
	if (low[x] + 1 <= up[x])    return low[x] + 1;
	return 0x3f3f3f3f;    //表示无解
}


vector<int>gg[maxn][2];
vector<int>ww[maxn][2];
LL h[maxn][2];
LL p[maxn][2];
int ans;
int tmp_output[maxn];
int vis[maxn][2];

void find(int a, int b)
{
	vis[a][b] = 1;
	if (h[a][b] == 0)    return;
	if (a == n)
	{
		for (int i = 1; i <= n; ++ i)
		{
			if (tmp_output[i] == output[i])    continue;
			if (tmp_output[i] > output[i])    return;
			if (tmp_output[i] < output[i])    break;
		}
		for (int i = 1; i <= n; ++ i)
			output[i] = tmp_output[i];
		return;
	}
	if (gg[a][b].size() == 0)    return;

	if (gg[a][b].size() == 1)
	{
		int j = gg[a][b][0];
		tmp_output[a+1] = ww[a][b][0];
		if (vis[a+1][j])    return;
		find(a + 1, j);
		return;
	}
	//否则先走字典序小的

	if (ww[a][b][0] > ww[a][b][1])
	{
		swap(ww[a][b][0], ww[a][b][1]);
		swap(gg[a][b][0], gg[a][b][1]);
	}


	int j1 = gg[a][b][0];
	int j2 = gg[a][b][1];
	tmp_output[a+1] = ww[a][b][0];
	if (!vis[a+1][j1])    find(a +1, j1);
	tmp_output[a+1] = ww[a][b][1];
	if (!vis[a+1][j2])    find(a + 1, j2);
}

void check()
{
	for (int i = 0; i <=n;++i)
		for (int j = 0; j <=1;++j)    
		{
			gg[i][j].clear();
			ww[i][j].clear();
		}
	memset(h, 0, sizeof(h));
	memset(p,0x3f, sizeof(p));

	h[0][0] = 1;//方案总数

	for (int i = 1; i <= n; ++ i)
	{
		if (f[i] == -1)
		{
			if (h[i - 1][0])    //前一位可以是偶数
			{

				if (h[i - 1][0] * get(i , 0))
				{
					gg[i - 1][0].push_back(0);            
					ww[i - 1][0].push_back(getnum(i, 0));
					h[i][0] += h[i - 1][0] * get(i , 0);
					h[i][0] %= mod;
					p[i][0] = mymin(getnum(i, 0), p[i][0]);
				}

				if (h[i - 1][0] * get(i,  1))
				{
					gg[i - 1][0].push_back(1);
					h[i][1] += h[i - 1][0] * get(i,  1);
					h[i][1] %= mod;
					p[i][1] = mymin(getnum(i, 1), p[i][1]);
					ww[i - 1][0].push_back(getnum(i, 1));
				}

			}
			if (h[i - 1][1])
			{

				if (h[i - 1][1] * get(i, 1))
				{
					gg[i - 1][1].push_back(0);
					h[i][0] += h[i - 1][1] * get(i, 1);
					h[i][0] %= mod;
					p[i][0] = mymin(getnum(i, 1), p[i][0]);
					ww[i - 1][1].push_back(getnum(i, 1));
				}
				if (h[i - 1][1] * get(i, 0))
				{
					gg[i - 1][1].push_back(1);
					h[i][1] += h[i - 1][1] * get(i, 0);
					h[i][1] %= mod;
					p[i][1] = mymin(getnum(i, 0), p[i][1]);
					ww[i - 1][1].push_back(getnum(i, 0));
				}
			}

		}
		else
		{
			int v=f[i];
			if (h[i - 1][0] * get(i, v ^ 0))
			{
				gg[i - 1][0].push_back(v);
				h[i][v] += h[i - 1][0] * get(i, v ^ 0);
				h[i][v] %= mod;
				p[i][v] = mymin(getnum(i, v ^ 0), p[i][v]);
				ww[i - 1][0].push_back(getnum(i, v^0));
			}
			if (h[i - 1][1] * get(i, v ^ 1))
			{
				gg[i - 1][1].push_back(v);
				h[i][v] += h[i - 1][1] * get(i, v ^ 1);
				h[i][v] %= mod;
				p[i][v] = mymin(getnum(i, v ^ 1), p[i][v]);
				ww[i - 1][1].push_back(getnum(i, v^1));
			}
		}
		if (!h[i][0] && !h[i][1])
		{
			//无解
			return;
		}

	}
	memset(vis, 0, sizeof(vis));
	find(0, 0);
	ans = (ans + h[n][0] + h[n][1]) % mod;
}

void dfs(int deep)
{
	if (deep > block_cnt)
	{
		check();
		return;
	}
	if (ranse(deep, 0))    dfs(deep + 1);
	if (ranse(deep, 1))    dfs(deep + 1);
}

void doit()
{
	ans = 0;
	for (int i = 0; i <= n; ++ i)
		if (!belong[i])    bfs(i);
	memset(output, 0x3f, sizeof(output));
	memset(f, -1, sizeof(f));
	if (belong[0] == 1)
	{
		//cout<<"!"<<endl;
		if (ranse(1, 0))    dfs(2);
		//否则显然无解啊
	}else
	{
		dfs(1);
	}
	printf("%lld\n", ans);
	if (ans == 0)
	{
		printf("-1\n");
		return;
	}
	for (int i = 1; i < n; ++ i)    printf("%d ", output[i]);
	printf("%d\n", output[n]);
}

int main()
{
	int T;
	scanf("%d", &T);
	while (T--)
	{
		init();
		doit();
	}
	return 0;
}


数据生成器：

#include <cstdio>
#include <stack>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <ctime>
#include <queue>
#include <ext/pb_ds/priority_queue.hpp>
using namespace std;

#define pr(x) cout<<#x<<" = "<<x<<" "
#define prln(x)	cout<<#x<<" = "<<x<<endl
//#define pr(x) x
//#define prln(x) x

typedef long long LL;
const LL mod = 1e9 + 7;

int n, m;
int output[2][1000];

int get(int a,int b)//返回a~b之间的数字
{
	return rand()%(b-a+1)+a;
}

void pg(int l , int r, int h, int p)
{
	cout<<get(l,r)<<" "<<get(h,p)<<endl;
}

int ot1[10000],ot2[10000], ot3[10000],t;
int mp[100][100];

/*

2
3 3
4 6
2 3
3 4
1 3 0
2 3 1
3 3 1
3 2
3 5
1 3
3 4
2 2 0
2 3 0
   
*/

int main()
{
	srand(time(0));
	ios::sync_with_stdio(false);
	int T=5;
	cout <<T<<endl;
	while (T--)
	{
		int n = 40;
		t=0;
		memset(mp,-1,sizeof(mp));
		for (int i = 1; i <= rand()%71 ; ++ i)	//穷举大概有多少约数
		{
			int a,b;
			a=get(1,n);
			b=get(1,n);
			mp[a][b]=mp[b][a]=rand()%2;
		}
		for (int i = 1; i<=n;++i)
			for (int j = i; j <= n; ++ j)
				if (mp[i][j] !=-1)
				{
					++t;
					ot1[t]=i;
					ot2[t]=j;
					ot3[t]=mp[i][j];
				}
		cout <<n<<" "<<t<<endl;
		for (int i = 1; i  <= n; ++ i)
		{
			LL x,y;
			LL p=1e9;
			x=((LL)rand()*(LL)rand())%p+1;
			y=((LL)rand()*(LL)rand())%p+1;

			if (x>y)	swap(x,y);

			if (x==y)	y+=1;
			cout<<x<<" "<<y<<endl;
		}
		for (int i = 1;i<=t;++i)	cout<<ot1[i]<<" "<<ot2[i]<<" "<<ot3[i]<<endl;

	}
	return 0;
}


CMTM4
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HDU 2009 求数列的和
蜗小牛的博客
10-12 2万+
求数列的和 Problem Description 数列的定义如下： 数列的第一项为n，以后各项为前一项的平方根，求数列的前m项的和。 Input 输入数据有多组，每组占一行，由两个整数n（n<10000）和m(m<1000)组成，n和m的含义如前所述。 Output 对于每组输入数据，输出该数列的和，每个测试实例占一行，要求精度保留2位小数。 Sample Input 81 4 2 ...
HDU DP 题集
04-24
动态规划(dynamic programming)是运筹学的一个分支，是求解决策过程(decision process)最优化的数学方法。20世纪50年代初美国数学家R.E.Bellman等人在研究多阶段决策过程(multistep decision process)的优化问题时，...
【HDU】5743 Join The Future【dp】
poursoul
10-08 475
题目链接：Join The Future并查集压缩相等的点，发现最多只会有20个大于1的联通块，状压dp即可#include <bits/stdc++.h> using namespace std ;typedef long long LL ;#define clr( a , x ) memset ( a , x , sizeof a )const int MAXN = 42 ; const int
hdu 5743 Join The Future
QZQ
07-24 877
http://acm.hdu.edu.cn/showproblem.php?pid=5743 令pre[i]为前i个数的和（mod 2）。 题中给的m个限制条件l,r,s，可以转化为pre[r] - pre[l-1] = s,就把区间转化为了点。每个限制条件表示两点间的关系  与其他 pre[] 都没有关系的 pre[i] 可以单独考虑。    而与其他数有限制关系 ，就至少与
【HDU5743 2016 Multi-University Training Contest 2J】【dfs展开式DP 前缀和思想】Join The Future 40个数已知区间和为奇或偶输出方案
snowy_smile的博客
07-28 774
Join The Future Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 118    Accepted Submission(s): 43 Problem Description Professor Zhang
区间DP——Kattis - runningroutes
行走天涯的豆沙包的博客
02-07 215
Kattis - runningroutes The administrators at Polygonal School want to increase enrollment, but they are unsure if their gym can support having more students. Unlike a normal, boring, rectangular gym, ...
DP - 区间DP - Coloring Brackets - CodeForces - 149D
njuptACMcxk的博客
04-21 139
DP - 区间DP - Coloring Brackets - CodeForces - 149D 题意： 给定一个仅由"()"构成的括号序列s(保证整个序列能成功匹配)，现给括号上色，需满足：①、每个括号要么不上色，要么红色，要么蓝色。②、一对匹配的括号仅有一个能够被上色。③、相邻的括号颜色不能相同，但可以都不上色。给定一个仅由"()"构成的括号序列s(保证整个序列能成功匹配)，现给括号上色，需...
DP.rar_DP_hdu_动态规划_动态规划 C++
09-20
动态规划DP题解 POJ HDU部分动态规划DP题解
code_hdu.rar_ACM_The First_hdu_test case example
09-23
For a positive integer n, let’s denote function f(n,m) as the m-th smallest integer x that x>n and gcd(x,n)=1. For example, f(5,1)=6 and f(5,5)=11. You are given the value of m and (f(n,m)?n)⊕n,...
初探数位dp.pdf
09-16
lazycal的集训队报告：初探数位DP 以HDU 2089，HDU 3652, URAL 1057等题目为例，介绍了数位DP的算法
HDU DP题解
02-07
HDU上DP大集合，里面包括题，题解，代码，对DP入门者很实用，对DP老手也是有很大的提高
HDU5743 多校2.9
风一样的自由，色彩斑斓的雨季
07-22 326
题目大意：求（a1+a2）/sum的最大值 思路：分子尽可能大就好 #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace std; #pragma comm
DP - 完全背包 - 整数划分
njuptACMcxk的博客
04-18 254
DP - 完全背包 - 整数划分 本题与——本题与——本题与——《Pay the Price - UVA - 10313》类似。类似。类似。 一个正整数n可以表示成若干个正整数之和，形如：n=n1+n2+…+nk，其中n1≥n2≥…≥nk,k≥1。 我们将这样的一种表示称为正整数n的一种划分。 现在给定一个正整数n，请你求出n共有多少种不同的划分方法。 输入格式 共一行，包含一个整数n。 输出格式...
动态规划
csdn_ggboy的博客
04-13 343
文章目录分类背包问题1、01背包2.完全背包 动态规划是把多阶段过程转化为一系列单阶段问题，利用各阶段之间的关系，逐个求解，解决这类过程优化问题的方法。 分类 解决动态思路规划问题有两种思路：一种是得到一个阶段的答案后推出所有与之直接相关的阶段的答案、另一种时由上一个阶段不断得到下一个阶段的答案。 背包问题 背包问题是最基础的动态规划问题，分为01背包、完全背包、多重背包等。 1、01背包 1....
HDU 2243 AC自动机->DP->附矩阵乘法板子
ACMer不要报考高校代码为13627的移通学院！
08-28 1810
题目大意： 给一些字母串，问长度为L【以内】的全部字母串中，有多少个字母串，【包含】给定的字母串。答案mod 2^64 首先，对于答案mod 2^64,只要全部使用unsigned long long进行运算，就会自动实现这个功能了。 然后假设，问题只求长度为L，而不是长度小于L的，这个问题怎么做呢？ 参考前一个题解…… 题目转换为求【不包含】给定字母串来
HDU 5732 2016多校Contest 1 Subway【找树的重心，判断树的同构】
ACMer不要报考高校代码为13627的移通学院！
08-04 1130
题目大意： 给定一棵树，这两棵树肯定是同构的。 问你，第一棵树的每个节点，可以对应第二个树的那个节点。 显然对应方法不唯一，SPJ来检测结果正确。 方法： 首先找树的重心， 树的重心最多2个。 一个重心的情况很多，两个重心的情况如图： 有人说这个图太对称了…… 那给个不对称的。  这个图很重要……涉及到一些奇怪的情况
【USACO2.3.2】奶牛家谱 动态规划
ACMer不要报考高校代码为13627的移通学院！
02-17 1087
f[k][n]表示 用N个节点，组成深度小于等于K层的方案数。 显然f[k][n] =sum( f[k - 1][p] + f[k - 1][q])  (p + q + 1 = n) 最终答案即为f[k][n] - f[k - 1][n] PS:short和int运算速度差不多啊卧槽 #include unsigned short f[101][201]
Codeforces Round #366 题解
ACMer不要报考高校代码为13627的移通学院！
08-09 835
Codeforces 366 Ant Man Black Widow
【USACO3.3.2】商店购物 状态压缩动态规划
ACMer不要报考高校代码为13627的移通学院！
03-22 628
节约空间我自然用了滚动数组…… 偷懒用指针来实现滚动了。 用二进制标志状态。 因为最多只买5种商品。 所以f[][][][][]   每一维空间表示每个商品购买的情况， 这里只说一下二维的情况  f[i][j] = f[a][b] + a[p]   其中：  b[p]+a = i     c[p] + b = j 说白了，就是用几维空间， 第一维，就是第一个商品的
hdu 2829 lawrence 斜率优化dp
最新发布
06-28
hdu 2829 Lawrence 斜率优化dp 这道题是一道经典的斜率优化dp题目，需要用到单调队列的思想。 题目大意是给定一个序列a，求出一个序列b，使得b[i]表示a[1]~a[i]中的最小值，且满足b[i] = min{b[j] + (i-j)*k}，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值