2017 济南集训DAY1.AF

Posted 2020-10-13 心之所向 素履以往

LIST

1. T1 水题(water)
2. T2 梦境(dream)
3. T2 动态规划(dp)

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。

 

思路：正解贪心

　　　用A中的一张牌 去覆盖 他能覆盖的牌中 最大的那个牌 

　　　把数组按照左端点排序 

　　　每一个A牌 去覆盖 他能覆盖的牌中 y最大的那个。

　　　支持 增加和删除操作　

　　　可以用某种数据结构来维护 (平衡树？ 权值线段树？)

　　　用multiset 即可

 1 #include <set>
 2 #include <cstdio>
 3 #include <cctype>
 4 #include <algorithm>
 5 
 6 const int MAXN=100010;
 7 
 8 int n,m;
 9 
10 struct node {
11     int x,y;
12     
13     friend inline bool operator < (node x,node y) {
14         return x.x < y.x;
15     }
16 };
17 node A[MAXN],B[MAXN];
18 
19 std::multiset<int> s;
20 
21 inline void read(int&x) {
22     int f = 1;register char c = getchar();
23     for(x = 0;!isdigit(c);c == \'-\' && (f = -1),c = getchar());
24     for(;isdigit(c);x = x * 10 + c - 48,c = getchar());
25     x = x * f;
26 }
27 
28 int main(int argc,char**argv) {
29     freopen("water.in","r",stdin);
30     freopen("water.out","w",stdout);
31     
32     read(n);
33     
34     for(int i = 1; i <= n; ++ i) read(A[i].x),read(A[i].y);
35     
36     for(int i = 1; i <= n; ++ i) read(B[i].x),read(B[i].y);
37     
38     std::sort(A + 1,A + 1 + n);
39     std::sort(B + 1,B + 1 + n);
40     
41     int k = 1,ans = 0;
42     for(int i = 1; i <= n; ++ i) {
43         while(A[i].x >= B[k].x && k <= n) {
44             s.insert(B[k].y);
45             ++k;
46         }
47         if(s.empty()) continue;
48         std::multiset<int>::iterator it=s.upper_bound(A[i].y);
49         if(it == s.begin()) continue;
50         --it;++ans;s.erase(it);
51     }
52     
53     printf("%d\\n",ans);
54     return 0;
55 }

代码

 

T2 梦境(dream)

梦境(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。

 

思路：求方案总数 我们可以考虑 搜索 或者 dp

　　　DFS(int num,int sum,int lim)

　　　num 设为第i个金币 sum为当前已有的金币总数 lim为上一个金币的数量 也是当前最大的金币数量

　　　每次枚举下一个的金币代表的钱的值 可以有60分 再加点玄学优化 可以A掉

　　　dp的话 

　　　我们不妨设 dp[i][j][k] 表示 有了i个金币 金币和为j 上一个金币数为k的 方案数

　　　显然 dp[i][j][k] 是由 dp[i-1][j-x][x] 转移而来 x为上一个的金币大小

　　　时间复杂度为O(n^2) 显然是足够的

　　　dp[i][j][k] 可以用滚动数组来优化一下或者直接去掉第一维

 1 #include <cmath>
 2 #include <cctype>
 3 #include <cstdio>
 4 #define max(x,y) ((x) < (y) ? (y) : (x))
 5 
 6 int n,t,ans;
 7 
 8 void DFS(int num,int sum,int lim) {
 9     if(num == t) {
10         if((sum << 1) + 1 < n) return;
11         ans += (sum << 1) + 1 - max(n,lim + sum + 1) + 1;
12         return;
13      }
14      for(int i = lim + 1; i<= sum + 1; ++ i) DFS(num + 1,sum + i, i);
15 }
16 
17 int main(int argc,char**argv) {
18     freopen("dream.in","r",stdin);
19     freopen("dream.out","w",stdout);
20     
21     scanf("%d",&n);
22     t = log2(n) + 1;
23     
24     DFS(1,0,0);
25     printf("%d %d\\n",t,ans);
26     return 0;
27 }

DFS

 1 #include <cmath>
 2 #include <cstdio>
 3 #include <cctype>
 4 #define min(x,y) ((x) < (y) ? (x) : (y))
 5 
 6 const int MAXN=1010;
 7 
 8 int n,t,ans;
 9 
10 int dp[2][MAXN][MAXN];
11 
12 int main(int argc,char**argv) {
13     freopen("dream.in","r",stdin);
14     freopen("dream.out","w",stdout);
15     
16     scanf("%d",&n);
17     t = log2(n) + 1;
18     dp[1][1][1] = 1;
19     for(int i = 2; i <= t; ++i)
20       for(int j = 1; j <= n; ++j)
21         for(int k = 1; k <= n; ++k)
22           if(dp[(i - 1)&1][j][k]) {
23               for(int l = k + 1; l <= j + 1; ++l) 
24                 dp[i&1][min(n, j + l)][l] += dp[(i - 1)&1][j][k];
25           }
26     for(int i = 1; i <=n ; ++i)
27       ans += dp[t&1][n][i];
28     printf("%d %d\\n",t,ans);
29     return 0;
30 }

DP

T3 动态规划(dp)

动态规划(dp)

Time Limit:1000ms   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完全相同均匀分布在所有数据中。

 

思路：当然还是dp (题目都说了嘛)

　　　不妨设 dp[i][j] 表示前i个数中 切了j刀的 最小值

　　　转移为 dp[i][j] = min(dp[i][j], dp[k][j-1] + f[k+1][i]) 

　　　k 为枚举的断点 f[i][j] i~j这段区间内 相同数的对数 

　　　复杂度为O(n^2) 

　　　由于 n是小于1e5的 显然要TLE 

　　　这时候 由1D1D动态规划优化 用分治来优化dp可以做到 O(k*n*logn) 

　　　1D1D 优化我不懂就不解释了 想看的点击链接即可

 1 #include <cstdio>
 2 #include <cctype>
 3 #include <cstring>
 4 #define min(x,y) ((x) < (y) ? (x) : (y))
 5 
 6 const int MAXN=1010;
 7 
 8 int n,m;
 9 
10 int dp[MAXN][MAXN],f[MAXN][MAXN],a[MAXN],sum[MAXN];
11 
12 inline void read(int&x) {
13     int f = 1;register char c = getchar();
14     for(x = 0;!isdigit(c);c ==\'-\'&&(f = -1),c = getchar());
15     for(;isdigit(c);x = x * 10 + c - 48,c = getchar());
16     x = x * f;
17 }
18 
19 int main(int argc,char**argv) {
20     freopen("dp.in","r",stdin);
21     freopen("dp.out","w",stdout);
22     
23     read(n);read(m);
24     for(int i = 1; i <= n; ++i) read(a[i]);
25     
26     for(int i = 1; i <= n; ++i) {
27         ++sum[a[i]];
28         for(int j = i + 1; j <= n; ++j) 
29           f[i][j] = f[i][j-1] + sum[a[j]],++sum[a[j]];
30         memset(sum,0,sizeof sum);
31     }
32     
33     memset(dp,127/3,sizeof dp);
34     for(int i = 0; i <= n; ++i) dp[i][0]=0;
35     for(int i = 1; i <= n; ++i) {
36         dp[i][1] = f[1][i];
37         for(int j = 2; j <= min(i,m); ++j)
38           for(int k = 0; k < i; ++k) 
39             dp[i][j] = min(dp[i][j], dp[k][j-1] + f[k+1][i]);
40     }
41     
42     printf("%d\\n",dp[n][m]);
43     return 0;
44 }

60分dp代码

 1 #include<cstdio>
 2 #include<cstring>
 3 
 4 using namespace std;
 5 
 6 typedef long long LL;
 7 
 8 #define N 100001
 9 
10 LL tot;
11 
12 int a[N];
13 
14 int cnt[N],L,R;
15 
16 LL f[N],g[N];
17 
18 void move(int l,int r)
19 {
20     while(L>l) --L,tot+=cnt[a[L]],cnt[a[L]]++;
21     while(L<l) cnt[a[L]]--,tot-=cnt[a[L]],L++;
22     while(R>r) cnt[a[R]]--,tot-=cnt[a[R]],R--;
23     while(R<r) ++R,tot+=cnt[a[R]],cnt[a[R]]++;
24 }
25 
26 void work(int l,int r,int opl,int opr)
27 {
28     if(opl>opr) return;
29     int mid=opl+opr>>1;
30     LL mi=1e18; int pos;
31     for(int i=l;i<=r;i++)
32     if(i<mid)
33     {
34         move(i+1,mid);
35         if(tot+f[i]<mi) mi=tot+f[i],pos=i;
36     }
37     g[mid]=mi;
38     work(l,pos,opl,mid-1);
39     work(pos,r,mid+1,opr);
40 }
41 
42 int main()
43 {
44     freopen("dp.in","r",stdin);
45     freopen("dp.out","w",stdout);
46     int n,k;
47     scanf("%d%d",&n,&k);
48     for(int i=1;i<=n;i++) scanf("%d",&a[i]);
49     f[0]=0;
50     for(int i=1;i<=n;i++) f[i]=1e18;
51     while(k--)
52     {
53         memset(cnt,0,sizeof(cnt));
54         tot=0; L=1; R=0;
55         work(0,n-1,1,n);
56         for(int i=1;i<=n;i++) f[i]=g[i],g[i]=0;
57     }
58     printf("%d",f[n]);
59 }

1D1D优化