2017 济南考前集训DAY1.AF

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 即可

#include <set>
#include <cstdio>
#include <cctype>
#include <algorithm>

const int MAXN=100010;

int n,m;

struct node {
    int x,y;
    
    friend inline bool operator < (node x,node y) {
        return x.x < y.x;
    }
};
node A[MAXN],B[MAXN];

std::multiset<int> s;

inline void read(int&x) {
    int f = 1;register char c = getchar();
    for(x = 0;!isdigit(c);c == '-' && (f = -1),c = getchar());
    for(;isdigit(c);x = x * 10 + c - 48,c = getchar());
    x = x * f;
}

int main(int argc,char**argv) {
    freopen("water.in","r",stdin);
    freopen("water.out","w",stdout);
    
    read(n);
    
    for(int i = 1; i <= n; ++ i) read(A[i].x),read(A[i].y);
    
    for(int i = 1; i <= n; ++ i) read(B[i].x),read(B[i].y);
    
    std::sort(A + 1,A + 1 + n);
    std::sort(B + 1,B + 1 + n);
    
    int k = 1,ans = 0;
    for(int i = 1; i <= n; ++ i) {
        while(A[i].x >= B[k].x && k <= n) {
            s.insert(B[k].y);
            ++k;
        }
        if(s.empty()) continue;
        std::multiset<int>::iterator it=s.upper_bound(A[i].y);
        if(it == s.begin()) continue;
        --it;++ans;s.erase(it);
    }
    
    printf("%d
",ans);
    return 0;
}

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
",t,ans);
26     return 0;
27 }

#include <cmath>
#include <cstdio>
#include <cctype>
#define min(x,y) ((x) < (y) ? (x) : (y))

const int MAXN=1010;

int n,t,ans;

int dp[2][MAXN][MAXN];

int main(int argc,char**argv) {
    freopen("dream.in","r",stdin);
    freopen("dream.out","w",stdout);
    
    scanf("%d",&n);
    t = log2(n) + 1;
    dp[1][1][1] = 1;
    for(int i = 2; i <= t; ++i)
      for(int j = 1; j <= n; ++j)
        for(int k = 1; k <= n; ++k)
          if(dp[(i - 1)&1][j][k]) {
              for(int l = k + 1; l <= j + 1; ++l) 
                dp[i&1][min(n, j + l)][l] += dp[(i - 1)&1][j][k];
          }
    for(int i = 1; i <=n ; ++i)
      ans += dp[t&1][n][i];
    printf("%d %d
",t,ans);
    return 0;
}

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 优化我不懂就不解释了 想看的点击链接即可

#include <cstdio>
#include <cctype>
#include <cstring>
#define min(x,y) ((x) < (y) ? (x) : (y))

const int MAXN=1010;

int n,m;

int dp[MAXN][MAXN],f[MAXN][MAXN],a[MAXN],sum[MAXN];

inline void read(int&x) {
    int f = 1;register char c = getchar();
    for(x = 0;!isdigit(c);c =='-'&&(f = -1),c = getchar());
    for(;isdigit(c);x = x * 10 + c - 48,c = getchar());
    x = x * f;
}

int main(int argc,char**argv) {
    freopen("dp.in","r",stdin);
    freopen("dp.out","w",stdout);
    
    read(n);read(m);
    for(int i = 1; i <= n; ++i) read(a[i]);
    
    for(int i = 1; i <= n; ++i) {
        ++sum[a[i]];
        for(int j = i + 1; j <= n; ++j) 
          f[i][j] = f[i][j-1] + sum[a[j]],++sum[a[j]];
        memset(sum,0,sizeof sum);
    }
    
    memset(dp,127/3,sizeof dp);
    for(int i = 0; i <= n; ++i) dp[i][0]=0;
    for(int i = 1; i <= n; ++i) {
        dp[i][1] = f[1][i];
        for(int j = 2; j <= min(i,m); ++j)
          for(int k = 0; k < i; ++k) 
            dp[i][j] = min(dp[i][j], dp[k][j-1] + f[k+1][i]);
    }
    
    printf("%d
",dp[n][m]);
    return 0;
}

#include<cstdio>
#include<cstring>

using namespace std;

typedef long long LL;

#define N 100001

LL tot;

int a[N];

int cnt[N],L,R;

LL f[N],g[N];

void move(int l,int r)
{
    while(L>l) --L,tot+=cnt[a[L]],cnt[a[L]]++;
    while(L<l) cnt[a[L]]--,tot-=cnt[a[L]],L++;
    while(R>r) cnt[a[R]]--,tot-=cnt[a[R]],R--;
    while(R<r) ++R,tot+=cnt[a[R]],cnt[a[R]]++;
}

void work(int l,int r,int opl,int opr)
{
    if(opl>opr) return;
    int mid=opl+opr>>1;
    LL mi=1e18; int pos;
    for(int i=l;i<=r;i++)
    if(i<mid)
    {
        move(i+1,mid);
        if(tot+f[i]<mi) mi=tot+f[i],pos=i;
    }
    g[mid]=mi;
    work(l,pos,opl,mid-1);
    work(pos,r,mid+1,opr);
}

int main()
{
    freopen("dp.in","r",stdin);
    freopen("dp.out","w",stdout);
    int n,k;
    scanf("%d%d",&n,&k);
    for(int i=1;i<=n;i++) scanf("%d",&a[i]);
    f[0]=0;
    for(int i=1;i<=n;i++) f[i]=1e18;
    while(k--)
    {
        memset(cnt,0,sizeof(cnt));
        tot=0; L=1; R=0;
        work(0,n-1,1,n);
        for(int i=1;i<=n;i++) f[i]=g[i],g[i]=0;
    }
    printf("%d",f[n]);
}