【URAL水题】集中题解区

原创 2012年03月29日 22:20:41

列出了难度在150以上的水题,150以下的就不列出了


http://acm.timus.ru/problem.aspx?space=1&num=1346

这道是动规题,我模拟做的,划分区间,找出最少的单调区间数量之和。

我想到了一个方法,但是不能证明。但是可以AC。

就是先求出该离散函数的所有单调区间之和,如果有连线后,有两个连续的拐点,则可以把这两点分开,分别包含于两个区间,对答案会减一。

但是如果说再有一个拐点紧接在后面的话就不能继续这样操作了。

/*		感觉有规律,但是没法证明。。	*\
\* 		可能不完美。对付URAL的测试足够了*/ 
#include <cstdio>

long a;long b;
long num[100010];
long n = 0;
int main()
{
	scanf("%ld%ld",&a,&b);
	b -= a-1;
	a = 1;
	long last = 0;
	for (long i=1;i<b+1;i++)
	{
		scanf("%ld",num+i);
		if (num[i]!=last)
		{
			last = num[i];
			num[++n] = num[i];
		}
	}
	long cnt = 1;
	long inc = num[2]>num[1]?1:-1;
	long continus = 0;
	for (long i=2;i<n+1;i++)
	{
		long tmp = num[i]>num[i-1]?1:-1;
		if (tmp != inc)
		{
			inc = -inc;
			cnt ++;
			continus++;
		}
		else
		{
			continus = 0;
		}
		
		/*								*\
			连续两个拐点,则从中间断开
			如果连续三个拐点,只能断开其中之一 
		\*								*/
		
		if (continus == 2)
		{
			cnt --;
			continus = 0;
		}
	}
	printf("%ld",cnt);
	return 0;
}
http://acm.timus.ru/problem.aspx?space=1&num=1167

简单的动规,线性的,也许可以单调队列优化,但是懒得了。用前缀和预处理出黑色马和白色马的数量。

注意宏定义的格式宏定义中一定要给每个参数加括号在最外层加括号,否则很容易出错

#include <cstdio>
#include <iostream>

long n;long K;
long col[510];
long sum[510];
long f[510][510];

//long BLACK(long a,long b){return (sum[b]-sum[a-1]);}
//long WHITE(long a,long b){return ((b-a+1)-(sum[b]-sum[a-1]));}

#define BLACK(a,b) (sum[b]-sum[a-1])
#define WHITE(a,b) (((b)-(a)+1)-(sum[(b)]-sum[(a)-1]))
/*							*\
宏定义中一定要给每个参数加括号
在最外层加括号 
\*							*/

#define MIN(a,b) (a<b?a:b)

int main()
{
	scanf("%ld%ld",&n,&K);
	for (long i=1;i<n+1;i++)
	{
		scanf("%ld",col+i);
		sum[i] = sum[i-1] + col[i];	
	}
	for (long i=0;i<n+1;i++)
		for (long j=0;j<K+1;j++)
			f[i][j] = 0x7f7f7f7f;
	f[0][0] = 0;
	for (long i=1;i<n+1;i++)
	{
		#ifdef Debug
		std::cerr << i << std::endl; 
		#endif
		for (long j=1;j<K+1&&j<i+1;j++)
		{
			f[i][j] = 0x7f7f7f7f;
			for (long k=0;k<i;k++)
			{
				f[i][j] = MIN(f[i][j],f[k][j-1]+BLACK(k+1,i)*WHITE(k+1,i));
			}
//			f[i][j] = MIN(f[i][j],f[i-1][j]);
		}
	}
	printf("%ld",f[n][K]);
	return 0;
}

http://acm.timus.ru/problem.aspx?space=1&num=1078

就是求最多有几个严格上一个包含下一个的区间。

很简单,先排一次序,第一关键字按l的升序,第二关键字按r的降序。并且把0号点区间设为(-inf,inf)

然后就是一个二维的动规。

#include <cstdio>
#include <algorithm>

long n;
const long inf = 0x7f7f7f7f;
long g[510];

struct node
{
	long l;
	long r;	
	long i;
	bool operator<(const node& n2)const 
	{
		if (l < n2.l) return true;
		if (l > n2.l) return false;
		if (r < n2.r) return false;
		return true;	
	}
};
node line[510];
long f[510];
long output[510];
long top = 0;

#define MAX(a,b) (a>b?a:b)

int main()
{
	scanf("%ld",&n);
	for (long i=1;i<n+1;i++)
	{
		scanf("%ld%ld",&line[i].l,&line[i].r);
		line[i].i = i;
	}
	std::sort(line+1,line+n+1);
	line[0].l = -inf;
	line[0].r = inf;
	long ans = 0;
	long des = 0;
	for (long i=1;i<n+1;i++)
	{
		for (long j=0;j<i;j++)
		{
			if (line[j].r > line[i].r && line[j].l < line[i].l)
			{
				if (f[j] + 1 > f[i])
				{
					f[i] = f[j] + 1;
					g[i] = j;
				}
			}
		}
		if (f[i] > ans)
		{
			ans = f[i];
			des = i;			
		}
	}
	printf("%ld\n",ans);
	long i = des;
	while (i)
	{
		output[++top] = line[i].i;
		i = g[i];
	}
	for (long i=1;i<top+1;i++)
	{
		printf("%ld ",output[i]);
	}
	return 0;
}


http://acm.timus.ru/problem.aspx?space=1&num=1157

年轻的瓦工。规模小。朴素方法就过了。

#include <cstdio>
#include <cmath>

long m;long n;long k;
long cnt = 0;

long ans(long x)
{
	long t = 0;
//	for (long i=1;i<=ceil(sqrt(double(x)));i++)
	for (long i=1;i<=long(sqrt(double(x))+0.5);i++)
	{
		if (x % i == 0) t++;
	}
	return t;
}

int main()
{
	scanf("%ld%ld%ld",&m,&n,&k);
	for (long i=k+1;i<10001;i++)
	{
		if (ans(i)==n&&ans(i-k)==m)
		{
			printf("%ld\n",i);
			return 0;
		}
	}
 	printf("0\n");
	return 0;
}

http://acm.timus.ru/problem.aspx?space=1&num=1029

貌似是那个什么数字三角形的变形。

逐层推。由于拓扑序不明显,有点乱,又是从左到右,又是从右到左,因此每一层用了两个临时数组来维护两个转移,然后再用两个数组更新F数组

#include <cstdio>
typedef long long ll;

long m;long n;

ll f1[510];
ll f2[510];
long g1[510];
long g2[510];
long g[110][510];
ll f[110][510];
long map[110][510];
long op[50010];
long top = 0;

int main()
{
	scanf("%ld%ld",&n,&m);
	for (long i=1;i<n+1;i++)
	{
		for (long j=1;j<m+1;j++)
		{
			scanf("%ld",map[i]+j);	
		}	
	}
	for (long i=1;i<n+1;i++)
	{
		f1[0] = f1[m+1] =
		f2[0] = f2[m+1] = 0x3f7f7f7f7f7f7f7fll;
		for (long j=1;j<m+1;j++)
			if (f[i-1][j]+(ll)map[i][j] < f1[j-1]+(ll)map[i][j])
			{
				f1[j] = f[i-1][j]+(ll)map[i][j];
				g1[j] = j;
			}
			else
			{
				f1[j] = f1[j-1]+(ll)map[i][j];
				g1[j] = j-1;
			}
			
		for (long j=m;j>0;j--)
			if (f[i-1][j]+(ll)map[i][j] < f2[j+1]+(ll)map[i][j])
			{
				f2[j] = f[i-1][j]+(ll)map[i][j];
				g2[j] = j;
			}
			else
			{
				f2[j] = f2[j+1]+(ll)map[i][j];
				g2[j] = j+1;
			}
		for (long j=1;j<m+1;j++)
		{
			if (f1[j] < f2[j])
			{
				f[i][j] = f1[j];
				g[i][j] = g1[j];	
			}
			else
			{
				f[i][j] = f2[j];
				g[i][j] = g2[j];
			}
		}
	}
	ll ans = 0x7f7f7f7f7f7f7f7fll;
	long des = 0;
	for (long j=1;j<m+1;j++)
	{
		if (ans > f[n][j])
		{
			ans = f[n][j];	
			des = j;
		}
	}
	long i = n;
	long j = des;
	while (g[i][j])
	{
		if (j == g[i][j])
		{
			op[++top] = j;
			i --;
		}
		else
		{
			op[++top] = j;
			j = g[i][j];	
		}
	}
	for (long i=top;i>0;i--)
	{
		printf("%ld ",op[i]);
	}
	//printf("%ld",ans);
	return 0;
}

http://acm.timus.ru/problem.aspx?space=1&num=1002

本来是字符串匹配+DP。但是C++优势,字符串匹配就直接搞定了。转移就很简单了。

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <string>
using std::min;
using std::string;
using std::cout;
using std::cin;
string PN;
string wrds[50010];
string wrds2[50010];
char chrctr[26] = {'2','2','2','3','3','3','4','4','1','1','5','5','6','6','0','7','0','7','7','8','8','8','9','9','9','0'};
long length[50010];
long f[50010];
long g[50010];
long pnlen;
long n;

void dp()
{
    for (long i=0;i<pnlen;i++)
    {
        g[i] = 0;
        f[i] = 0x7f7f7f7f;
    }
    for (long i=1;i<n+1;i++)
    {
        if (PN.compare(0,length[i],wrds[i],0,length[i])==0)
        {
            f[length[i]-1] = 1;
            g[length[i]-1] = i;
        }
    }
    for (long i=1;i<pnlen;i++)
    {
        for (long j=1;j<n+1;j++)
        {
            if (i-length[j]>=0 && PN.compare(i-length[j]+1,length[j],wrds[j],0,length[j])==0)
            {
                if (f[i-length[j]]+1 < f[i])
                {
                    f[i] = f[i-length[j]]+1;
                    g[i] = j;
                }
            }
        }
    }
}

void ou(long l)
{
    if (g[l] == 0)return;
    ou(l-length[g[l]]);
    cout << wrds2[g[l]] << " ";
}

void translate(long l)
{
    for (long i=0;i<length[l];i++)
    {
        wrds[l][i] = chrctr[wrds[l][i]-'a'];
    }
}

int main()
{
    freopen("phone.in","r",stdin);
    freopen("phone.out","w",stdout);
    while (1)
    {
        cin >> PN;
        if (PN == "-1") break;
        pnlen = PN.length();
        cin >> n;

        for (long i=1;i<n+1;++i)
        {
            cin >> wrds[i];
            wrds2[i] = wrds[i];
            length[i] = wrds[i].length();
            translate(i);
        }
        dp();
        if (f[pnlen-1]<0x7f7f7f7f) ou(pnlen-1);
        else cout << "No solution.\n";
        cout << "\n";
    }
}

Ural 1091 Tmutarakan Exams (水题 容斥+ 莫比乌斯反演)

Ural 1091 Tmutarakan Exams (水题 容斥+ 莫比乌斯反演)

URAL 2035 Another Dress Rehearsal 水题、易错

虽然是水题但也WA了两发, 尴尬, 第一次WA, 是对于 x > c && y > c的情况没有处理好 第二次WA, 是由于 0 ≤ A ≤ X, 0 ≤ B ≤ Y 没有注意, 因为 A最大不能...

timus 1346. Intervals of Monotonicity URAL 解题报告 DP 小水题,阅读理解

timus  1346. Intervals of Monotonicity URAL 解题报告 坑死人的小破题,给一个数列,然后判断这个数列的complexity 是多少,所谓的complexit...

个人排位赛--a 物理题,水题 URAL - 1939

物理题 排位赛

Python3 ural水题集锦

1025. Democracy in Danger Time limit: 1.0 second Memory limit: 64 MB Background In one of the co...

URAL 2025 Line Fighting 水题、贪心、均分

贪心 尽可能均摊 t = n/k; res = n - t*k; 然后res个 t+1, n - res 个t, 然后算下就好了 复杂度 O(n)...

【URAL 1873】【超级坑水题】 GOV Chronicles

其实一开始让我做这题,我是拒绝的,最后我发现,题目其实已经告诉了我们三个数字,而且20就是题目的最大次数,也就说每个都在20之间,那我们就可以知道我们可以尝试的次数是20^8 = 25 600 000...

2016年安徽省程序设计竞赛 水题C,D,E 题解

A,B太水了就不写了- - 感觉思路都挺清楚的,不多解释了 C.转啊转 Time Limit: 1000 MS Memory Limit: 65536 KB ...

【休闲杯】AK大派送水题赛 题解

第一题: 第一题很简单,直接在输入之后,布尔类型数组相应的区域覆盖就可以了。 #include using namespace std; bool a[1000005]; //布尔数组,表示...

NYOJ水题题解-63小猴子下落(memset,三目运算符,左移运算符 )

题目: 时间限制:3000 ms  |  内存限制:65535 KB 难度:3 描述 有一颗二叉树,最大深度为D,且所有叶子的深度都相同。所有结点从左到右从上到下的编号为1,2,3,·····,...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:【URAL水题】集中题解区
举报原因:
原因补充:

(最多只允许输入30个字)