zoj DP(二)

最新推荐文章于 2022-03-28 17:51:35 发布
最新推荐文章于 2022-03-28 17:51:35 发布
阅读量860 收藏
点赞数 1
分类专栏： zoj
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bigdata_lijun/article/details/9025543
版权

zoj1092

#include <stdio.h>
#include <string.h>
#include <math.h>
#define zero 0.000001

int main()
{
	char name[30][300];
	char from[300], to[300];
	double g[30][30];
	double rate;
	int flag;
	int i,j,k;
	int n,m;
	int cases = 1;
	while(scanf("%d", &n) && n)
	{
		memset(g, 0, sizeof(g));
		for(i=0; i<n; i++)
			scanf("%s", name[i]);
		scanf("%d", &m);
		for(i=0; i<m; i++)
		{
			scanf("%s%lf%s",from, &rate, to);
			for(j=0; j<30; j++)
				if (strcmp(from,name[j])==0) break;
			for(k=0; k<30; k++)
				if (strcmp(to,name[k])==0) break;
			g[j][k] = log(rate);
		}
		for(k=0; k<n; k++)
			for(i=0; i<n; i++)
				for(j=0; j<n; j++)
				{
					rate = g[i][k]+g[k][j];
					if(g[i][j]<rate) g[i][j] = rate;
				}
		flag = 0;
		for(i=0; i<n; i++)
			if (g[i][i]>zero) flag = 1;
		printf("Case %d: ", cases++);
		printf("%s\n", flag ? "Yes" : "No");
	}
	return 0;
}

zoj1117 

#include <stdio.h>
#include <string.h>

struct {
	int lchild, rchild, parent;
}tree[64];

char text[100];
int freq[64];
int optimal;

void entropy(int n, int d)
{
	if(freq[n]==0) return;
	if(n<31) optimal += freq[n]*d;
	else
	{
		entropy(tree[n].lchild, ++d);
		entropy(tree[n].rchild, d);
	}
}

int main()
{
	int i,j;
	int left,right;
	while(gets(text))
	{
		if (strcmp(text,"END")==0) break;
		int length = strlen(text);
		memset(tree, 255, sizeof(tree));
		memset(freq, 0, sizeof(freq));
		for(i = 0; i<length; i++)
			if (text[i]=='_') freq[26]++;
			else freq[text[i]-'A']++;
		int node = 30;
		while(1)
		{
			int min = 1000;
			for(j = 0; j<=node; j++)
				if(tree[j].parent==-1)
					if(min>freq[j] && freq[j])
					{
						min = freq[j];
						left = j;
					}
			min = 1000;
			for(j = 0; j<=node; j++)
				if(tree[j].parent==-1)
					if(j!=left && min>freq[j] && freq[j])
					{
						min = freq[j];
						right = j;
					}
			if (min==1000) break;
			freq[++node]  = freq[left] + freq[right];
			tree[node].lchild = left;
			tree[node].rchild = right;
			tree[node].parent = -1;
			tree[left].parent = node;
			tree[right].parent = node;
		}
		optimal = 0;
		if(node==30) optimal = length;
		else entropy(node,0);
		length *= 8;
		printf("%d %d %.1lf\n", length, optimal, 1.0*length/optimal);
	}
	return 0;
}

zoj1118 

#include<iostream>
#include<map>
using namespace std;

map<string,int> maps;
int set[200];

int findhead(int number)
{
	if(set[number]==number) return number;
	else
	{
		set[number] = findhead(set[number]);
		return set[number];
	}
}

int build(char path[], int &count)
{
	int index;
	if(maps.find(string(path))==maps.end())
	{
		maps[string(path)] = ++count;
		index = count;
		set[count] = count;
		
	}
	else index = maps[string(path)];
	return index;
}

int main()
{
	int n;
	int number = 1;
	while(scanf("%d",&n) && n)
	{
		int i;
		int p;
		char starting[15], ending[15];
		for(i = 0; i<n; i++)
		{
			scanf("%d", &p);
			starting[i] = p+'0';
		}
		starting[n] = 0;
		for(i = 0; i<n; i++)
		{
			scanf("%d", &p);
			ending[i] = p+'0';
		}
		ending[n] = 0;

		int count = 0;
		maps.clear();
		char path[15];
		while(scanf("%d", &p))
		{
			if(p==-1) break;
			int start, end;
			path[0] = p+'0';
			for(i = 1; i<n; i++)
			{
				scanf("%d", &p);
				path[i] = p+'0';
			}
			path[n] = 0;
			start = build(path, count);			
			for(i = 0; i<n; i++)
			{
				scanf("%d", &p);
				path[i] = p+'0';
			}
			path[n] = 0;
			end = build(path, count);
			int h1 = findhead(start);
			int h2 = findhead(end);
			if(h1!=h2) set[h1] = h2;
		}
		int possible = 1;
		if(maps.find(string(starting))==maps.end() 
			|| maps.find(string(ending))==maps.end())
			possible = 0;
		else
		{
			int start = maps[string(starting)];
			int end = maps[string(ending)];
			int h1 = findhead(start);
			int h2 = findhead(end);
			if(h1!=h2) possible = 0;
		}
		if (possible) printf("Maze #%d can be travelled\n",number++);
		else printf("Maze #%d cannot be travelled\n",number++);
	}
	return 0;
}

zoj1119 

#include<stdio.h>
#include<memory.h>


const int Node  = 1000;
int n;
bool G[Node][Node];
int father[Node];
int order[Node];
int low[Node];
bool visited[Node];


void DFS(int v, int d)
{
	if (visited[v]) return;
	low[v] = d;
	order[v] = d;
	visited[v] =  true;
	for (int i = 0; i < n; i++) {
		if (G[v][i]) {
			if (visited[i]) 
				low[v] = low[v]<order[i]?low[v]:order[i];
			else {
				father[i] = v;
				DFS(i, d+1);
				low[v] = low[v]<low[i]?low[v]:low[i];
			}
		}
	}
}


void SPF()
{
	for (int i = 0; i < n; i++) 
	{
		visited[i] = false;
		father[i]  = -1;
		low[i]	 = 0;
		order[i] = 0;
	}
	for (int i = 0; i < n; i++) 
		if (!visited[i]) DFS(i, 1);
	
	bool find = false;
	for (int i = 0; i < n; i++) 
	{
		int subnet = 0;
		for (int j = 0; j < n; j++) 
			if ((father[j] == i) && (low[j] >= order[i])) 
				subnet++;
		if (subnet > 0) {
			if (father[i] == -1) {
				if (subnet > 1) {
					find = true;
					printf("  SPF node %d leaves %d subnets\n", i+1, subnet);
				}
			} 
			else {
				find = true;
				printf("  SPF node %d leaves %d subnets\n", i+1, subnet+1);
			}
		}
	}
	if (!find) {
		printf("  No SPF nodes\n");
	}
}


int main(){
	int i,j;
	int number = 0; 
	memset(G, 0, sizeof(G)); 
	while(scanf("%d", &i)) { 
		if(i==0) {
			if(number) putchar('\n'); 
			printf ("Network #%d\n", ++number); 
			SPF();
			scanf("%d", &i);
			if (i==0) break;
			memset(G, 0, sizeof(G)); 
		}
		n = -1; 
		scanf("%d", &j); 
		if(i>n) n = i; 
		if(j>n) n = j; 
		G[i-1][j-1] = G[j-1][i-1]=1; 
	}
}

zoj1127 

#include <stdio.h>
#include <memory.h>

int   city;
char  graph [26][26];
char  fortify [26];

int Dijkstra()
{
	int i, j, k;
	int searched [26];
	int hop [26];
	for ( i = 0; i < city; i ++ )
		if ( fortify [i] ) hop [i] = 0;
			else hop [i] = 100;
	memset(searched, 0, sizeof(searched));
	for ( i = 0; i < city; i ++ ) {
		k = -1;
		for ( j = 0; j < city; j ++ )
			if ( !searched [j] ) 
				if ( k < 0 || hop [j] < hop [k] ) k = j;
		if ( k < 0 ) break;
		searched [k] = 1;
		for ( j = 0; j < city; j ++ )
			if (!searched [j])
				if ( graph [k][j] && hop [k] + 1 < hop [j] )
					hop [j] = hop [k] + 1;
	}

	j = -1;
	for ( i = 0; i < city; i ++ )
		if ( !fortify [i] )
			if ( j < 0 || hop [j] < hop [i] ) j = i;
	fortify [j] = 1;
	return j;
}

int main ()
{
	int i;
	int total;
	char first, str[10];
	char a , b;
	scanf("%d%s%d\n", &city, str, &total);
	first = str[0];
	memset (fortify, 0, sizeof(fortify));
	memset (graph, 0, sizeof(graph));
	for ( i = 1; i < city; i ++ ) 
	{
		scanf("%c %c\n", &a, &b);
		graph[a-'A'][b-'A'] = 1;
		graph[b-'A'][a-'A'] = 1;
	}
	fortify [first - 'A'] = 1;
	printf("Program 8 by team X\n");
	printf("%c", first);
	for (i = 1; i < total; i ++ )
		printf(" %c", Dijkstra() + 'A');
	printf("\n");
	printf("End of program 8 by team X\n");
	return 0;
}

zoj1134 

#include <stdio.h>
#include <string.h>

#define maxV 1501
int pos[maxV];
int size[maxV]; 
int f1[maxV], f2[maxV];

struct Edge
{		
	int x, y; 
}edge[maxV];

void dp( int now )
{
	f1[now] = 1; 
	f2[now] = 0;
	if (size[now]==0) return; 
	int v;
	int i = pos[now]; 
	while(edge[i].x ==now)
	{
		v = edge[i++].y;
		dp( v );
		f1[now] += f1[v]<f2[v]?f1[v]:f2[v];
		f2[now] += f1[v];
	}
}

int main()
{
	int i, j;
	int u, v, num;
	int node, leaf;
	int V;
	while( scanf("%d", &V )!=EOF )
	{
		int idx = 1; 
		node = leaf = 0;
		for( i=1; i<=V; i++ )
		{
			scanf("%d:(%d)", &u, &num );
			node +=u;
			pos[u] = idx;
			size[u] = num;
			for( j=1; j<=num; j++ )
			{
				scanf("%d", &v );
				leaf +=v;
				edge[idx].x = u; 
				edge[idx++].y = v;
			}
		}
		int root = node-leaf;
		dp(root);
		printf("%d\n", f1[root]<f2[root]?f1[root]:f2[root]);
	}
	return 0;
}

zoj1137 

#include<stdio.h>
#include<memory.h>
#define M 500

int n,m;
int match[M];
char used[M];
int g[M][20];

int dfs(int stu)
{
	int i;
	int x, t;
	for(i=1; i<=g[stu][0]; i++)
	{
		x = g[stu][i];
		if(!used[x])
		{
			used[x] = 1;
			t = match[x];
			match[x] = stu;
			if(t==-1||dfs(t)) return 1;
			match[x] = t;
		}
	}
	return 0;
}

int bipartite()
{
	int stu;
	int res = 0;
	memset(match, -1, sizeof(match));
	for(stu=0; stu<n; stu++)
	{
		memset(used, 0, sizeof(used));
		if(dfs(stu)) res++;
	}
	return res;
}

int main()
{
	int i, j;
	int a, b;
	while(scanf("%d",&n)!=EOF)
	{
		memset(g, 0, sizeof(g));
		for(i=0; i<n; i++)
		{
			scanf("%d: (%d)", &a, &m);
			g[a][0] = m;
			for(j=1; j<=m; j++)
			{
				scanf("%d", &b);
				g[a][j] = b;
			}
		}
		printf("%d\n",n-bipartite()/2);
	}
	return 0;
}

zoj1140 

#include <stdio.h>
#include <memory.h>

#define MAXN 301
int match[MAXN];
int used[MAXN];
int g[MAXN][120];

int dfs(int course){
	int x, t;
	int i;
	for (i = 1; i<=g[course][0]; ++i){
		x = g[course][i];
		if (!used[x]){
			t = match[x];
			match[x] = course; 
			used[x] = 1;
			if (t == 0 || dfs(t)) return 1;
			match[x] = t;
		}
	}
	return 0;
}
int main(){
	int cases;
	scanf("%d", &cases);
	while (cases--){
		int i, j;
		int n, p;
		scanf("%d%d", &p, &n);
		for (i = 1; i <= p; ++i){
			scanf("%d", &g[i][0]);
			for (j = 1; j<=g[i][0]; ++j) 
				scanf("%d", &g[i][j]);
		}
		memset(match, 0, sizeof(match));
		for (i = 1; i <= p; ++i){
			memset(used, 0, sizeof(used));
			dfs(i);
		}
		int res = 0;
		for (i = 1; i <= n; ++i){
			if (match[i]>0) ++res;
		}
		if (res == p) printf("YES\n"); 
		else printf("NO\n");
	}
	return 0;
}


不仅仅是寻找
关注
专栏目录
【题解】zoj3747 线性DP
翻过这座山，他们就会听到你的故事
08-15 233
思路摘抄自大佬博客 由于又是至多又是至少没办法处理，所以统一转换成至多，对于事件A={至多N个G士兵连续}，事件B={至多m-1个G士兵连续},那么A-B={连续人数在m到n中取值，即至少m个连续士兵}。统一之后，设定一个二维数组，dp[i][3]，dp[i][0]表示对于第i个位置，放G士兵，同理,dp[i][1],dp[i][2]分别表示第i个位置放R，和P。 最大连续u个G，连续v个R；...
zoj3537(区间dp)
ACM之梦
12-11 801
最有三角形划分，凸包不会也抄了别人的凸包代码一直wa不明觉厉，不过dp算是想对了； #include #include #include #include #include using namespace std; typedef long long lld; #define oo 0x3f3f3f3f #define mod 1000000007 #define maxn 300+5 int
zoj DP(一)
06-04 831
zoj1013 #include #include int trade[501][501], carry[501][501]; int min(int a, int b) { return a<b?a:b; } int main() { int iCase = 0; int n; while(scanf("%d", &n) && n) { if(iCase++) pri
zoj1163 (很经典很好的DP)
lizy3838的博客
02-05 728
啊啊啊啊啊啊短短不到30行代码看死我了，现在也没有完全理解，明天继续学习，DP之路还很长，ACM之路还很长 状态 dp[i][j] 表示有 i 个积木时 最后一列不大于j个积木的总和。 转移方程： dp[i][j]=dp[i-j][j-1]+dp[i][j-1]; 以下是代码：#include #include #include #include using namespace s
匈牙利算法裸题zoj1140
k0_0k的博客
07-29 365
题目链接：zoj1140 裸裸的匈牙利模板题。 不过提醒自己注意的是vis数组的处理——每次找左边下一个点的增广路匹配时，vis要清零；以及，如果递归找不到一次递归深搜找不到增广路时，回溯前不能将vis数组清零。 vis数组在尝试找增广路的过程中，置1可以看作是临时匹配（至于为什么找不到回溯前不能清零，我也没太想明白，不过如果清零的化有时候会反复递归陷入死循环，，黑哥说递归要返回上层状态，如...
POJ 1469 ZOJ1140 二分匹配裸题
Nicolas
09-04 1273
很裸，左点阵n，右点阵m 问最大匹配是否为n #include #include #include using namespace std; vector edge[103]; int pre[303]; bool vis[303]; int n, m; bool dfs(int u) { for(int i = 0; i < (int)edge[u].size(); i++) {
zoj 1140 Courses
ZekiDai的博客
03-28 328
md,匹配题感觉全是二分图+匈牙利 #include<iostream> #include<cstring> #include<algorithm> #include<math.h> #include<vector> #include<set> #include<queue> #include<list> #include<map> using namespace std; const int max
ZOJ1003 Crashing Balloon
03-22
【ZOJ1003 Crashing Balloon】这个问题是一个经典的计算机科学竞赛编程题目，主要涉及动态规划（Dynamic Programming, DP）和贪心算法（Greedy Algorithm）的知识点。在这个问题中，参赛者需要编写程序来模拟气球...
ZOJ月赛 题解 (ZOJ Monthly, August 2014)
01-22
**ZOJ月赛题解 (ZOJ Monthly, August 2014)** ZOJ（Zhejiang Online Judge）是中国著名的在线编程竞赛平台之一，它为程序员和学生提供了丰富的算法练习和比赛机会。2014年8月的ZOJ月赛是一场面向广大编程爱好者的...
zoj 3229 期望dp 比较经典
晴朗的博客
04-30 530
/* 思路从这个 博客：http://blog.csdn.net/morgan_xww/article/details/6775853 思路：（//后面是我自己添加上的帮助理解，其余解题思路的是转载，我用的记忆化搜索写的） dp求期望的题。 题意： 有三个均匀的骰子，分别有k1,k2,k3个面，初始分数是0， 当掷三个骰子的点数分别为a,b,c的时候，分数清零，否则
zoj 1140-zju 2433 简单题的部分答案
03-05
zoj 1140-zju 2433 简单题的部分答案 都是可以正确通过的，简洁易懂
zoj 1140 poj 1469 COURSES（二分图匹配 匈牙利算法）
youngkl博客
12-02 908
COURSES Time Limit: 1000MS   Memory Limit: 10000K Total Submissions: 17974   Accepted: 7084 Description Consider a group of N students and P courses. Each student visit
ZOJ1140-Courses—匈牙利算法
zjutsunny的博客
11-12 176
#include<cstdio> #include<cstring> #include<queue> #include<iostream> using namespace std; #define P 110 #define N 310 int p; int n; int map[P][N]; int match[N]; bool use[N]; ...
[ZOJ1140]Courses 课程
a5163273的博客
02-06 125
Description 给出课程的总数P（1<=p<100)，学生的总数N(1<=N<=300) 每个学生可能选了一门课程，也有可能多门，也有可能没有. 要求选出P个学生来组成一个协会，每个学生代表一门课程， 且每门课程都有一个学生来代表它。 Input 先是测试数据的个数。 再是P，N 下列P行，代表从第一门课到第P门课程的学生选修的情况。先给出有多少人选修，再...
POJ 1469 && ZOJ 1140 --COURSES【二分图 && 最大匹配】
_阿阿阿阿欢
08-24 475
COURSES Time Limit: 1000MS   Memory Limit: 10000K Total Submissions: 19581   Accepted: 7709 Description Consider a group of N students and P courses. Each student visit
POJ 1469 ZOJ 1140 Courses 二分图匹配
weixin_30808253的博客
04-09 103
继续匈牙利二分匹配，其实我都不知道怎样写匈牙利算法，只是记住了可以这样写，悲哀啊 唉```` 裸的二分匹配，贴代码： View Code 1 #include <cstdio> 2 #include <cstring> 3 #define MAXC 105 4 #define MAXS 305 5 bool g[MAXC][MAXS]; ...
ZOJ1140:Courses
BootStar
04-03 483
http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1140 这题求解的是二分图的最大匹配，只要匹配住可以"盖住"每门课程，即匹配数与课程数量相等，委员会就可以成立。在这里集合课程中的元素是相互独立的，学生集合中的元素也是相互独立的，因而判定这个是二分图。然后采用二分图的匈牙利算法即可。 代码如下： #include
zoj搜索（二）
06-04 1233
zoj1084 #include #include bool g[26][26]; int used[26]; int n; bool dfs(int id, int color) { int i, j; bool flag; for (i = 0; i < color; i++) { flag = true; used[id] = i; for (j = 0; j
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值