[11.2]日常模拟.2

//贪心 + DP被完虐
//30 + 20 + 40

#T1#
水题(water)
Time Limit:1000ms Memory Limit:128MB
题目描述
LYK出了道水题。
这个水题是这样的：有两副牌，每副牌都有n张。
对于第一副牌的每张牌长和宽分别是xi和yi。对于第二副牌的每张牌长和宽分别是aj和bj。第一副牌的第i张牌能覆盖第二副牌的第j张牌当且仅当xi>=aj并且yi>=bj。（注意牌不能翻转）当然一张牌只能去覆盖最多一张牌，而不能覆盖好多张。
LYK想让两副牌的各n张 一 一 对应叠起来。它想知道第二副牌最多有几张能被第一副牌所覆盖。
输入格式(water.in)
第一行一个数n。
接下来n行，每行两个数xi,yi。
接下来n行，每行两个数aj,bj。
输出格式(water.out)
输出一个数表示答案。
输入样例
3
2 3
5 7
6 8
4 1
2 5
3 4
输出样例
2
数据范围
对于50%的数据n<=10。
对于80%的数据n<=1000。
对于100%的数据1<=n<=100000，1<=xi,yi,aj,bj<=10^9。

//想过贪心但没想对
正解是贪心 + stl(或dalao数据结构)

对x[i]从小到大进行排序。
每次遇到B类牌，将y值插入进某个数据结构中
遇到A类牌（不考虑x），找这个数据结构中y值尽可能大且不超过这张牌的y值。

关于set和multiset可以看blog

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

const int maxn = 100000 + 100;
int n,ans = 0;
struct edge {
	int x,y,val; //1为第一幅，2为第二幅 
}e[maxn << 1];
multiset<int>q;

bool cmp(edge a,edge b) {
	if(a.x != b.x)return a.x < b.x;
	else return a.val > b.val;
}

int read() {
	int x = 0,f = 1;
	char ch = getchar();
	while(ch < '0' || ch > '9') {
		if(ch == '-') f = -1;
		ch = getchar();
	}
	while(ch >= '0' && ch <= '9') {
		x = (x << 1) + (x << 3) + ch - '0';
		ch = getchar();
	}
	return x * f;
}

int main() {
	freopen("water.in","r",stdin);
	freopen("water.out","w",stdout);
	n = read();
	for(int i = 1; i <= n; ++i) 
		e[i].x = read(), e[i].y = read(), e[i].val = 1; 
	for(int i = n + 1; i <= n + n; ++i)
		e[i].x = read(), e[i].y = read(), e[i].val = 2;
	n *= 2;
	sort(e + 1, e + 1 + n, cmp);

	for(int i = 1; i <= n; i++) {
		if(e[i].val == 2) {
			q.insert(e[i].y);
		}
		else {
			if(q.empty()) continue;
			multiset<int>::iterator it = q.upper_bound(e[i].y);
			if(it == q.begin()) continue;
			it--;ans++; 
			q.erase(it);
		}
	}
	cout<<ans<<endl;			
	return 0;
}

#T2#
梦境(dream)
Time Limit:1000ms Memory Limit:128MB
题目描述
LYK做了一个梦。
这个梦是这样的，LYK是一个财主，有一个仆人在为LYK打工。
不幸的是，又到了月末，到了给仆人发工资的时间。但这个仆人很奇怪，它可能想要至少x块钱，并且当LYK凑不出恰好x块钱时，它不会找零钱给LYK。
LYK知道这个x一定是1~n之间的正整数。当然抠门的LYK只想付给它的仆人恰好x块钱。但LYK只有若干的金币，每个金币都价值一定数量的钱（注意任意两枚金币所代表的钱一定是不同的，且这个钱的个数一定是正整数）。LYK想带最少的金币，使得对于任意x，都能恰好拼出这么多钱。并且LYK想知道有多少携带金币的方案总数。
具体可以看样例。
输入格式(dream.in)
第一行一个数n，如题意所示。
输出格式(dream.out)
输出两个数，第一个数表示LYK至少携带的金币个数，第二数表示方案总数。
输入样例
6
输出样例
3 2
样例解释
LYK需要至少带3枚金币，有两种方案，分别是{1,2,3}，{1,2,4}来恰好得到任意的1~n之间的x。
输入样例2
10
输出样例2
4 8
数据范围
对于30%的数据n<=10。
对于60%的数据n<=100。
对于100%的数据n<=1000。

//第一问是个找规律题，很容易发现min = log2（n）；
//第二问我以为也是个规律结果不对，搞了20分

以下是暴力模拟手推过程，60分

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

const int maxn = 1000 + 100;

int read(){
	int x = 0,f = 1;
	char ch = getchar();
	while(ch < '0' || ch > '9') {
		if(ch == '-') f = -1;
		ch = getchar();
	}
	while(ch >= '0' && ch <= '9') {
		x = (x << 1) + (x << 3) + ch - '0';
		ch = getchar();
	}
	return x * f;
}
int n,f[maxn],t,ans;

//x为金币最大值，sum为金币和，num为金币数
void dfs(int x,int sum,int num) {
	if(num == t) {
		if(sum >= n) ans++;
		return;
	}
	for(int i = x + 1; i <= sum + 1; i++) {
		dfs(i,sum + i, num + 1);
	}
}

int main() {
	freopen("dream.in","r",stdin);
	freopen("dream.out","w",stdout);
	n = read();
	t = (log(n) / log(2) + 0.00000001) + 1;
	dfs(0,0,0);
	cout<<t<<' '<<ans;
	return 0;
}

正解是DP
dp[i][j][k] 当前有i个金币，金币和是j，最大的金币k。
可以再开个数组DP，来优化空间

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

const int maxn = 1000 + 100;

int read(){
	int x = 0,f = 1;
	char ch = getchar();
	while(ch < '0' || ch > '9') {
		if(ch == '-') f = -1;
		ch = getchar();
	}
	while(ch >= '0' && ch <= '9') {
		x = (x << 1) + (x << 3) + ch - '0';
		ch = getchar();
	}
	return x * f;
}
int n,f[maxn],t,ans,dp[maxn][maxn],DP[maxn][maxn];

int main() {
	freopen("dream.in","r",stdin);
	freopen("dream.out","w",stdout);
	n = read();
	t = (log(n) / log(2) + 0.00000001) + 1;
	dp[1][1] = 1;
	for(int i = 1; i < t; i++) {
		for(int j = 1; j <= n; j++) { 
			for(int k = 1; k <= n; k++) {
				if(dp[j][k]) {
					for(int l = k + 1; l <= j + 1; l++) {
						DP[min(n, j+l)][l] += dp[j][k];
					}
				}
			}
		}
		for(int j = 1; j <= n; j++) {
			for(int k = 1; k <= n; k++) {
				dp[j][k] = DP[j][k];
				DP[j][k] = 0;
			}
		}
	}
	for(int i = 1; i <= n; i++) ans += dp[n][i];
	cout<<t<<' '<<ans;
	return 0;
}

#T3#
动态规划(dp)
Time Limit:2000ms Memory Limit:128MB
题目描述
LYK在学习dp，有一天它看到了一道关于dp的题目。
这个题目是这个样子的：一开始有n个数，一段区间的价值为这段区间相同的数的对数。我们想把这n个数切成恰好k段区间。之后这n个数的价值为这k段区间的价值和。我们想让最终这n个数的价值和尽可能少。
例如6个数1,1,2,2,3,3要切成3段，一个好方法是切成[1],[1,2],[2,3,3]，这样只有第三个区间有1的价值。因此这6个数的价值为1。
LYK并不会做，丢给了你。
输入格式(dp.in)
第一行两个数n,k。
接下来一行n个数ai表示这n个数。
输出格式(dp.out)
一个数表示答案。
输入样例
10 2
1 2 1 2 1 2 1 2 1 2
输出样例
8
数据范围
对于30%的数据n<=10。
对于60%的数据n<=1000。
对于100%的数据1<=n<=100000,1<=k<=min(n,20),1<=ai<=n。
其中有30%的数据满足ai完全相同均匀分布在所有数据中。

//读错题，以为要输出一个片段最小的
//然后就二分暴力解了

40分错误解法

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
#define ll long long

const int maxn = 100000 + 100;
int n,k;
int a[maxn],f[maxn];

int read() {
	int x = 0,f = 1;
	char ch = getchar();
	while(ch < '0' || ch > '9') {
		if(ch == '-') f = -1;
		ch = getchar();
	}
	while(ch >= '0' && ch <= '9') {
		x = (x << 1) + (x << 3) + ch - '0';
		ch = getchar();
	}
	return x * f;
}

ll tt;

bool pd(ll mid) {
	ll ans = 0;
	memset(f,0,sizeof(f));
	ll sum = 0,m = 1;
	for(int i = 1; i <= n; i++) {
		if(sum + f[a[i]] > mid) {
			memset(f,0,sizeof(f));
			sum = 0;
			m++;
		}		
		if(m > k) return false;
		sum += f[a[i]];
		ans += f[a[i]];
		f[a[i]]++;
	}
	tt = ans;
	return true;
}

int main() {
	freopen("dp.in","r",stdin);
	freopen("dp.out","w",stdout);
	n = read(), k = read();
	for(int i = 1; i <= n; i++) a[i] = read();
	ll r = 0, l = 5000000000;
	while(r <= l) {
		ll mid = (r + l) >> 1;
		if(pd(mid))	l = mid - 1;
		else r = mid + 1;
	}
	cout<<tt<<endl;
}

正解是DP，还有什么1D1D优化，这对于dp渣来说太难了，所以不改了