10.1综合强化刷题 Day1 afternoon

一道图论好题(graph)

Time Limit:1000ms   Memory Limit:128MB

 

题目描述

LYK有一张无向图G={V,E}，这张无向图有n个点m条边组成。并且这是一张带权图，不仅有边权还有点权。

LYK给出了一个子图的定义，一张图G’={V’,E’}被称作G的子图，当且仅当

·G’的点集V’包含于G的点集V。

·对于E中的任意两个点a,b∈V’，当(a,b)∈E时，(a,b)一定也属于E’，并且连接这两个点的边的边权是一样的。

LYK给一个子图定义了它的价值，它的价值为：点权之和与边权之和的比。 看

LYK想找到一个价值最大的非空子图，所以它来找你帮忙啦。

 

输入格式(graph.in)

第一行两个数n,m表示一张n个点m条边的图。

第二行n个数ai表示点权。

接下来m行每行三个数u,v,z，表示有一条连接u,v的边权为z的无向边。数据保证任意两个点之间最多一条边相连，并且不存在自环。

 

输出格式(graph.out)

你需要输出这个价值最大的非空子图的价值，由于它是一个浮点数，你只需要保留小数点后两位有效数字。

 

输入样例

3 3

2 3 4

1 2 3

1 3 4

2 3 5

 

输出样例

1.67

 

样例解释

选择1,2两个点，则价值为5/3=1.67。

 

对于20%的数据n=2

对于50%的数据n<=5

对于100%的数据1<=n,m<=100000，1<=ai,z<=1000。

 

70分做法：  这个题老师似乎讲过，老师当时说这个题是一个脑筋急转弯的题，最优的情况一定为两个点+一条边，正确性证明？？

我们选3个点的条件一定是边上那两个点的点权一定比中间那个点的点权大，不然选他干嘛、、这样的话我们设a>c>b，然后我们来看我们剩下的是要比较（a+b）*B   ,c*A或者是(b+c)*A,a*B的大小，如果（b+c）*A(b+c)/B，我们也可以推出(a+b+c)/A+B<(a+b)/A,反之同理，也就是说无论我们让他们的和大于其中的一个，也一定能推出来他小于另一个，也就是说含有三个点的一定比含有两个点比值小，即最有情况一定是两个点+一条边。

啊啊啊，ans<（double）(q/z)这个样子比较大小会wa两个点，改成这样ans<(q*1.0/z)就可以得到90分、、

#include
#include
#include
#include
#include
#define N 100010
using namespace std;
double ans;
int n,m,x,y,z,q,v[N];
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*10+ch-'0',ch=getchar();
    return x*f;
}
int main()
{
    freopen("graph.in","r",stdin);
    freopen("graph.out","w",stdout);
    n=read(),m=read();
    for(int i=1;i<=n;i++) v[i]=read();
    for(int i=1;i<=m;i++)
    {
        x=read(),y=read(),z=read();
        q=v[x]+v[y];
        if(ans<(double)(q/z)) ans=(double)q/z;
    }
    printf("%.2lf",ans);
}

70分，一个点TLE，wa两个点

#include
#include
#include
#include
#include
#define N 100010
using namespace std;
double ans;
int n,m,x,y,z,q,v[N];
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*10+ch-'0',ch=getchar();
    return x*f;
}
int main()
{
    freopen("graph.in","r",stdin);
    freopen("graph.out","w",stdout);
    n=read(),m=read();
    for(int i=1;i<=n;i++) v[i]=read();
    for(int i=1;i<=m;i++)
    {
        x=read(),y=read(),z=read();
        q=v[x]+v[y];
        if(ans<(q*1.0/z)) ans=q*1.0/z;
    }
    printf("%.2lf",ans);
}

AC代码

 

 

 

 

拍照(photo)

Time Limit:1000ms   Memory Limit:128MB

 

题目描述

假设这是一个二次元。

LYK召集了n个小伙伴一起来拍照。他们分别有自己的身高Hi和宽度Wi。

为了放下这个照片并且每个小伙伴都完整的露出来，必须需要一个宽度为ΣWi，长度为max{Hi}的相框。（因为不能叠罗汉）。

LYK为了节省相框的空间，它有了绝妙的idea，让部分人躺着！一个人躺着相当于是身高变成了Wi，宽度变成了Hi。但是很多人躺着不好看，于是LYK规定最多只有n/2个人躺着。（也就是说当n=3时最多只有1个人躺着，当n=4时最多只有2个人躺着）

LYK现在想问你，当其中部分人躺着后，相框的面积最少是多少。

 

输入格式(photo.in)

第一行一个数n。

    接下来n行，每行两个数分别是Wi,Hi。

 

输出格式(photo.out)

你需要输出这个相框的面积最少是多少。

 

输入样例

3

3 1

2 2

4 3

 

输出样例

27

 

样例解释

如果没人躺过来，需要27的面积。

我们只要让第1个人躺过来，就只需要21的面积！

 

对于30%的数据n<=10。

对于60%的数据n<=1000，Wi,Hi<=10。

对于100%的数据1<=n,Wi,Hi<=1000。

 

 n^2枚举，本以为会TLE的、、、

现将每一组数按高度排序，然后我们枚举我们当前相框的高度，然后看看我们是n/2个人躺下以后是否会满足条件，如果满足条件更新ans，否则继续枚举，我们对于h

#include
#include
#include
#include
#include
#define N 1010
#define LL long long
using namespace std;
LL ans;
bool flag;
int n,s,h,w,sum,b[N];
struct Node
{
    int w,h;
}a[N];
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*10+ch-'0',ch=getchar();
    return x*f;
}
int cmp(Node a,Node b){return a.h<b.h;}
int main()
{
    freopen("photo.in","r",stdin);
    freopen("photo.out","w",stdout);
    n=read();s=n/2;
    for(int i=1;i<=n;i++) 
    {
        a[i].w=read(),a[i].h=read();
        for(int j=1;j)
         if(a[i].h>a[j].h) b[a[j].h]++;
    }
    ans=0x7fffffff;
    sort(a+1,a+1+n,cmp);
    for(int i=1;i<=n;i++)
    {
        h=a[i].h;
        flag=false,w=0;sum=b[h];
        if(sum>s) continue;
        for(int j=1;j<=n;j++)
        {
            if(a[j].h<=h) 
            {
                if(a[j].w>a[j].h&&a[j].w<=h&&sum;
                else w+=a[j].w;
            }
            else 
            {
                if(a[j].w<=h) w+=a[j].h;
                else {flag=true;break;}
            }
        }
        if(!flag) ans=min(ans,(LL)h*w);
    }
    printf("%lld",ans);
    return 0;
}

90分代码，wa一个点

 一直认为要按高度排序，结果wa掉一个点，将排序方法改成按高度与宽度的差值就可以A掉了，正确性证明？？

 （对于一个高度满足的人，你要判断是是否撂倒他肯定首先撂倒能使照片尽量小的人，也就是说你要保证撂倒他后，他原来的宽在范围内，且他倒后，产生的影响就是改变的宽的和，尽量使和小所以你需要给高度和跨度差排序）

#include
#include
#include
#include
#include
#define N 1010
#define LL long long
using namespace std;
LL ans;
bool flag;
int n,s,h,w,sum,b[N],maxn;
struct Node
{
    int w,h;
}a[N];
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*10+ch-'0',ch=getchar();
    return x*f;
}
int cmp(Node a,Node b){return a.w-a.h>b.w-b.h;}
int main()
{
    freopen("photo.in","r",stdin);
    freopen("photo.out","w",stdout);
    n=read();s=n/2;
    for(int i=1;i<=n;i++) 
    {
        a[i].w=read(),a[i].h=read(),maxn=max(maxn,max(a[i].w,a[i].h));
        for(int j=1;j)
         if(a[i].h>a[j].h) b[a[j].h]++;
    }
    ans=0x7fffffff;
    sort(a+1,a+1+n,cmp);
    for(int h=1;h<=maxn;h++)
    {
        flag=false,w=0;sum=b[h];
        if(sum>s) continue;
        for(int j=1;j<=n;j++)
        {
            if(a[j].h<=h) 
            {
                if(a[j].w>a[j].h&&a[j].w<=h&&sum;
                else w+=a[j].w;
            }
            else 
            {
                if(a[j].w<=h) w+=a[j].h;
                else {flag=true;break;}
            }
        }
        if(!flag) ans=min(ans,(LL)h*w);
    }
    printf("%lld",ans);
    return 0;
}

AC代码

 

 

或和异或(xor)

Time Limit:2000ms   Memory Limit:128MB

 

题目描述

LYK最近在研究位运算，它研究的主要有两个：or和xor。（C语言中对于|和^）

为了更好的了解这两个运算符，LYK找来了一个2^n长度的数组。它第一次先对所有相邻两个数执行or操作，得到一个2^(n-1)长度的数组。也就是说，如果一开始时a[1],a[2],…,a[2^n]，执行完第一次操作后，会得到a[1] or a[2],a[3] or a[4] ,…, a[(2^n)-1] or a[2^n]。

第二次操作，LYK会将所有相邻两个数执行xor操作，得到一个2^(n-2)长度的数组，假如第一次操作后的数组是b[1],b[2],…,b[2^(n-1)]，那么执行完这次操作后会变成b[1] xor b[2], b[3] xor b[4] ,…, b[(2^(n-1))-1] xor b[2^(n-1)]。

第三次操作，LYK仍然将执行or操作，第四次LYK执行xor操作。如此交替进行。

最终这2^n个数一定会变成1个数。LYK想知道最终这个数是多少。

为了让这个游戏更好玩，LYK还会执行Q次修改操作。每次修改原先的2^n长度的数组中的某一个数，对于每次修改操作，你需要输出n次操作后（最后一定只剩下唯一一个数）剩下的那个数是多少。

 

输入格式(xor.in)

第一行两个数n，Q。

接下来一行2^n个数ai表示一开始的数组。

接下来Q行，每行两个数xi,yi，表示LYK这次的修改操作是将a{xi}改成yi。

 

输出格式(xor.out)

Q行，表示每次修改操作后执行n次操作后剩下的那个数的值。

 

输入样例

2 4

1 6 3 5

1 4

3 4

1 2

1 2

 

输出样例

1

3

3

3

 

样例解释

第一次修改，{4,6,3,5}->{6,7}->{1}

第二次修改，{4,6,4,5}->{6,5}->{3}

第三次修改，{2,6,4,5}->{6,5}->{3}

第四次修改，{2,6,4,5}->{6,5}->{3}

对于30%的数据n<=17，Q=1。

对于另外20%的数据n<=10，Q<=1000。

对于再另外30%的数据n<=12，Q<=100000。

对于100%的数据1<=n<=17，1<=Q<=10^5，1<=xi<=2^n，0<=yi<2^30，0<=ai<2^30。

 

哈哈，打了个我认为一定全部TLE的程序，结果竟然得了50分（准是看本姑娘太可爱了、、）

暴力做法：枚举每一次修改，我们暴力进行操作，我们判断这是进行到第几次操作，然后我们进行分类讨论，如果操作数是奇数的话我们将原数组进行|操作，如果数偶数的话我们进行^操作，对于每一次操作，我们暴力将数组内的每两个数之间进行操作，然后将我们处理出来的数存入一个sum数组里，然后在复制到原来的b数组里。然后重复进行这样的操作，直到我们的数组里只剩下一个数，结束操作

#include
#include
#include
#include
#include
#include
#define N 150000
using namespace std;
int n,q,s,c,x,y,cnt,a[N],b[N],sum[N];
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*10+ch-'0',ch=getchar();
    return x*f;
}
int main()
{
    freopen("xor.in","r",stdin);
    freopen("xor.out","w",stdout);
    n=read(),q=read();
    for(int i=1;i<=pow(2,n);i++)
     a[i]=read();
    while(q--)
    {
        cnt=pow(2,n);
        x=read(),y=read(),a[x]=y;
        for(int i=1;i<=cnt;i++) b[i]=a[i];
        while(cnt!=1)
        {
            s++;c=cnt,cnt=0;
            if(s%2==0)
            {
                for(int i=1;i<=c;i+=2)
                 sum[++cnt]=b[i]^b[i+1];
                for(int i=1;i<=cnt;i++)
                 b[i]=sum[i];
            }
            else
            {
                for(int i=1;i<=c;i+=2)
                 sum[++cnt]=b[i]|b[i+1];
                for(int i=1;i<=cnt;i++)
                 b[i]=sum[i];
            }
            if(cnt==1) printf("%d\n",sum[cnt]);
        }
    }
    return 0;
}

50分的暴力

 

据说这道题线段树可以做，在向上跟新父亲的时候用|或者^，据说std用的倍增

看到q个询问，每次修改一个值我们就应该能够想到用线段树，并且我们知道最后全部合并成一个数的时候即为我们的线段树合并成一个的时候，那么这样的话用线段树就显而易见了（可是蒟蒻表示并没看出来、、），但是我们要怎么用线段树呢？？

我们需要记录当前我们所在的层数，我们知道当操作为奇数的话我们进行|操作，也就是我们在更新父亲的时候需要将它的子节点的值|一下，同理如果为偶数的话我们进行^操作

#include
#include
#include
#include
#include
#include
#define N 150000
using namespace std;
int n,q,x,y;
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*10+ch-'0',ch=getchar();
    return x*f;
}
struct Tree
{
    int l,r,v,f;
}tree[N*4];
void build(int k,int l,int r,int dep)
{
    tree[k].l=l,tree[k].r=r;
    if(l==r)
    {
        tree[k].v=read();
        return ;
    }
    int mid=(l+r)>>1;
    build(k<<1,l,mid,dep+1);
    build(k<<1|1,mid+1,r,dep+1);
    if((n-dep+1)&1) tree[k].v=tree[k<<1].v|tree[k<<1|1].v;
    else tree[k].v=tree[k<<1].v^tree[k<<1|1].v;
}
void change(int k,int dep)
{
    if(tree[k].l==tree[k].r) 
    {
        tree[k].v=y;
        return ;
    }
    int mid=(tree[k].l+tree[k].r)>>1;
    if(x<=mid) change(k<<1,dep+1);
    else change(k<<1|1,dep+1);
    if((n-dep+1)&1) tree[k].v=tree[k<<1].v|tree[k<<1|1].v;
    else tree[k].v=tree[k<<1].v^tree[k<<1|1].v;
}
int main()
{
    freopen("xor.in","r",stdin);
    freopen("xor.out","w",stdout);
    n=read(),q=read();
    build(1,1,1<1);
    while(q--)
    {
        x=read(),y=read();
        change(1,1);
        printf("%d\n",tree[1].v);
    }
    return 0;
}

AC代码

 

 

 

　　　　　　　　　　　　　　　　

 

　　　　　　　　　　　　　　　　　　　　　　距 NOIp2017 还剩 30 天

 　　                             你可以做的事情还有很多，即使到最后一秒也不要放弃，因为不到结束的那一刻谁也不知道结果会怎样。

转载于:https://www.cnblogs.com/z360/p/7647689.html