2017暑假第二阶段第三场总结

最新推荐文章于 2020-07-24 03:02:30 发布

rgnoH

最新推荐文章于 2020-07-24 03:02:30 发布

阅读量530

点赞数

分类专栏：一些总结堆可并堆 DP 状态压缩最小生成树

本文链接：https://blog.csdn.net/rgnoH/article/details/77511391

版权

DP 同时被 3 个专栏收录

23 篇文章 0 订阅

订阅专栏

一些总结

15 篇文章 0 订阅

订阅专栏

状态压缩

9 篇文章 0 订阅

订阅专栏

T1 数正方形

问题描述

在n * n的点阵中任取4个点，回答：问题1：这4个点恰好是“正放”的正方形的4个顶点的方案数是多少？
问题2：这4个点恰好是正方形(包括“正放”和“斜放”)的4个顶点的方案数是多少？

输入格式

两个整数n和k，n表示点阵的尺寸，k=1表示需要回答问题1，k=2表示需要回答问题2

输出格式

一个整数，表示答案。（模1000000007再输出）

数据范围

n<=100000

注意不要将下面说的“边长”与题目中所给的顶点数弄混。

正放的情况比较简单。对于边长为i的正方形，其右上角顶点的选择显然有(n-i) $^2$ 种。那么答案就是 1 $^2$ +2 $^2$ +3 $^2$ +……+(n-1) $^2$ ，即 $\frac{1}{6}$ n(n-1)(2n-1).

对于斜放的情况，为了有条理而不遗漏地考虑，把每个斜放正方形考虑成四个顶点都在某个正放的正方形的情况。那么对于边的点数为i的正放正方形，满足上述条件的斜放正方形有i-2个。（斜放正方形总是各一个顶点在正放正方形的各边。这样的顶点不能为正方正方形的顶点，所以可供选择的点有i-2个）

进一步分析并根据相关公式，可以做到O(1)。
当K=2时，答案为 $\frac{1}{12}$ $（N^4-N^2）$

#include<iostream>
using namespace std;
const long long mod=1000000007LL;
int main()
{
    unsigned long long N,K;
    cin>>N>>K;
    if(K==1)cout<<(N-1)*N*(N*2-1)/6%mod;
    else cout<<(N*N%mod*N*N%mod-N*N%mod+mod)*83333334%mod;
    //83333334为该意义下的乘法逆元
}

然而在比赛时更容易用O(n)解决K=2的情况：


#include<stdio.h>
#include<iostream>
#define ll unsigned long long
#define mod 1000000007LL
using namespace std;
ll f[100005];

int main()
{
    ll N,K,i,Ans;

    cin>>N>>K;
    Ans=N*(N-1)*(2*N-1)/6%mod;
    if(K==1)return cout<<Ans,0;
    for(i=3;i<=N;i++)f[i]=(f[i-1]+(i-2)*(i-1)*(2*i-3)/6)%mod;
    Ans+=f[N];
    cout<<Ans%mod;
}

T2 取数

题目描述

n个整数组成的一个环，现在要从中取出m个数，取走一个数字就不能取跟它相邻的数字(相邻的数不能同时取)。要求取出的数字的总和尽可能大，问这个最大和是多少？如果无解，请输出“Error!”

输入格式

第一行包含两个正整数n、m。
第二行为n个整数Ai。

输出格式

仅一个整数，表示所求结果。如果无解输出“Error!”，不包含引号

数据范围

对于全部数据：n<=200000；m<=n；-1000<=Ai<=1000

可以说是目前见过的一道神题，没想到堆还能有这种操作。

易得当且仅当m*2>n时，输出”Error!”

对于有解的情况，首先容易想到DP。设f[i][j][0/1]表示从前i个数中选j个的最大结果，最后一维是0代表第i位不选，是1代表选第i位，容易得到状态转移方程：

$f[i][j][1]=f[i-1][j-1][0]+A[i]$
$f[i][j][0]=max(f[i-1][j][1],f[i-1][j][0])$

注意到转移方程中第一维中i的情况只与i-1的情况有关，可以通过滚动数组优化空间。时间复杂度O(mn)，这样只能过部分数据。

通过数据规模可以猜出可能是时间复杂度O(nlogn)级别的算法。事实上正解不是DP，而是用堆解决。其中使用到了“通过添加代替删除”这一数据结构中常用思路。

首先将所有数字及其编号压入大根堆中，接下来进行如下流程：

1.取出堆顶元素。若该元素已讨论过则重复该流程，否则将它的值加给Ans并跳至步骤2。
2.向堆中添加一个新元素：编号为之前的元素总个数+1，值为堆顶元素左边和右边的元素之和减去堆顶元素的值。
3.将堆顶元素及其左右元素标记为已讨论过，维护新元素左边与右边的元素。

关键在于步骤2，作用是“反悔”。显然，最优解中不一定包含有最大的元素，通过这个操作可以实现将原来的元素改为选择它左右的元素，从而得到更优解。

具体细节参照代码。

#include<stdio.h>
#include<queue>
#define MAXN 400005
using namespace std;
int N,M,L[MAXN],R[MAXN],tot,Ans,val[MAXN];
bool mark[MAXN];
priority_queue<pair<int,int> >Q;
//在优先队列中,pair的前一个元素优先级高于后一个元素
int main()
{
    int i,x,p,v;

    scanf("%d%d",&N,&M);
    if(N<M*2)return puts("Error!"),0;

    for(i=1;i<=N;i++)
    {
        scanf("%d",&val[i]);
        L[i]=i-1;R[i]=i+1;
        Q.push(make_pair(val[i],i));
    }
    L[1]=N;R[N]=1;
    tot=N;

    for(i=1;i<=M;i++)
    {
        p=Q.top().second;
        v=val[p];
        Q.pop();
        if(mark[p]){i--;continue;}
        Ans+=v;
        v=val[++tot]=val[L[p]]+val[R[p]]-v;
        mark[L[p]]=mark[R[p]]=mark[p]=true;
        L[tot]=L[L[p]];
        R[tot]=R[R[p]]; 
        L[R[R[p]]]=tot;
        R[L[L[p]]]=tot;
        Q.push(make_pair(v,tot));
    }

    printf("%d",Ans);
}

T3 葡萄酒交易

题目描述

某地分布着N个村庄，编号0到N-1,每个村庄要么需要买酒，要么需要卖酒。
设第i个村庄对葡萄酒的需求为Ai,其中Ai>0表示该村需要买酒，Ai<0表示该村需要卖酒。所有村庄供需平衡,即所有Ai之和等于0 (∑Ai =0)。
不过，只有M对村庄之间存在贸易往来，其中第i对村庄之间无论运输多少葡萄酒，都要花费Ti的运费。请你计算最少需要多少运费就可以满足所有村庄对酒的需求。

输入格式

第一行两个整数N、M。
第二行N个整数Ai。
接下来M行每行三个整数pi,qi,Ti，表示在编号为pi和qi的村庄之间运酒需要花费Ti的费用。数据保证每对pi、qi最多出现一次。

输出格式

输出一个整数表示答案。无解输出Impossible

数据范围

对于 50% 的数据：2<=N<=8。
对于 100% 的数据：
2<=N<=16
0<=M<=N*(N-1)/2
0<=pi,qi < N
-1000<=Ai<=1000
0<=Ti<=1000

注意到N的规模极小,那么可以考虑状压DP。

首先考虑无解的情形：
如果把原图看成若干个互不相交的连通块，那么当且仅当存在某一连通块中供需不平衡时，问题无解。

根据无解的判定出发寻找有解时的思路：
如果仅考虑一个供需平衡的连通块，当答案最优时，路径应为该连通块的最小生成树。（如果不考虑一开始就供需平衡的点（Ai=0），有供应的点要输出，有需求的点要引进，即每个点都至少要有一条边与之相连）

然而要注意以下为错解（但因为数据弱仍然可以骗到几乎满分）：分别求这些互不相交的连通块的最小生成树，再把各生成树的权值相加。有以下反例：

求整个连通块的最小生成树不一定比分别求小连通块的最小生成树加起来更优

可见求整个连通块的最小生成树不一定比分别求小连通块的最小生成树加起来更优。

所以接下来就可以将所有供需平衡的连通块看成物品，整个图看成背包，将这些连通块的最小生成树作为物品的价值，通过状态压缩进行背包动规。

由于本题综合性很强，同时考察了最小生成树、DP、状态压缩，所以对于各个算法的细节要处理好。

#include<stdio.h>
#include<algorithm>
#include<cstring>
#define Min(x,y) ((x<y)?(x):(y))
using namespace std;

struct node{int a,b,len;}line[200];
bool operator<(node x,node y){return x.len<y.len;}
int N,M,A[20],Lim,sum[66666],V[66666],f[66666];

int fa[20];
int gf(int x)
{
    if(fa[x]!=x)fa[x]=gf(fa[x]);
    return fa[x];
}

int Kruscal(int x)
{
    int i,ans=0,cnt=0,cp=0,tmp=x,fx,fy;

    while(tmp)cp+=(tmp&1),tmp>>=1;
    for(i=1;i<=N;i++)fa[i]=i;//注意每次都要对并查集初始化

    for(i=1;i<=M;i++)
    if(((x>>line[i].a-1)&1)&&((x>>line[i].b-1)&1))//只考虑在当前状态下合法的边
    {
        fx=gf(line[i].a);fy=gf(line[i].b);
        if(fx==fy)continue;
        fa[fx]=fy;
        cnt++;
        ans+=line[i].len;
    }
    if(cnt!=cp-1)return 1e9;//说明当前状态不连通
    return ans;
}

int main()
{
    int i,j,x,y,z;

    scanf("%d%d",&N,&M);
    for(i=1;i<=N;i++)scanf("%d",&A[i]);
    for(i=1;i<=M;i++)
    {
        scanf("%d%d%d",&x,&y,&z);
        line[i].a=x+1;line[i].b=y+1;line[i].len=z;
    }

    Lim=(1<<N)-1;
    sort(line+1,line+M+1);

    for(i=1;i<=Lim;i++)
    for(j=0;j<N;j++)if(i&(1<<j))sum[i]+=A[j+1];

    for(i=1;i<=Lim;i++)
        if(!sum[i])V[i]=Kruscal(i);//只计算供需平衡的状态的最小生成树

    for(i=1;i<=Lim;i++)f[i]=1e9;
    for(i=0;i<=Lim;i++)
    {
        if(sum[i])continue;
        for(j=0;j<=Lim;j++)
        {
            if(sum[i])continue;
            f[i|j]=Min(f[i|j],(f[j]+V[i]));
        }
    }

    if(f[Lim]==1e9)puts("Impossible");
    else printf("%d",f[Lim]);
}

总结

由于T1推导错误(推导时计算重了)，T2的暴力DP在枚举答案时把一二维弄反（从而导致直接开爆空间弃疗），T3把题意理解错误以至于只写了个输出Impossible骗分（连最小生成树都没想到），本次应该是考得最惨的一次，接近爆零。

对于T1，简单题的分要拿快拿稳，思考时尤其要注意逻辑的严密性。
对于T2，平心而论，即使再来三个小时，也不一定能想到正解。暴力方法要写快写准，虽然不是正解，也要稳拿该拿到的分。吸取到的经验是：数据规模太大时，要么通过转换讨论方法、记录前缀和或最大值、利用单调队列、线段树等数据结构优化DP，要么就不考虑DP。
对于T3，根据数据规模显然可以猜测出正解是状压DP，要加强题目理解能力，否则还有希望AC。

rgnoH

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
2017暑假第二阶段第三场总结

T1 数正方形问题描述在n * n的点阵中任取4个点，回答：问题1：这4个点恰好是“正放”的正方形的4个顶点的方案数是多少？问题2：这4个点恰好是正方形(包括“正放”和“斜放”)的4个顶点的方案数是多少？输入格式两个整数n和k，n表示点阵的尺寸，k=1表示需要回答问题1，k=2表示需要回答问题2输出格式一个整数，表示答案。（模1000000007再输出
复制链接

扫一扫