MZOJ 2018-03-31 考试随想

第一道题，先是题看错了，贪心的时候没有贪心对，改了1mol，最后才改对，预计正常用时20min。

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

const int maxn=10000+10;
const long long mods=1000000009;

int n;
long long t=0;
long long ans=0;

struct node{
    int x,y;
}peo[maxn];

bool cmp(node a,node b)
{
    return a.x*b.y < a.y*b.x; 
}

void readdate()
{
    int ai,bi;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%d%d",&ai,&bi);
        peo[i].x=ai;
        peo[i].y=bi;
    }
    sort(peo+1,peo+1+n,cmp);
    return ;
}

void work()
{
    for(int i=1;i<=n;i++)
    {
        ans=((ans+peo[i].x+peo[i].y*ans)+mods)%mods;
    }
    cout<<ans<<endl;
}

int main()
{
    readdate();
    work();
    return 0;
}

 

 

---

---

---

 

第二道题也十分简单，不就是一个普通的加减值问题吗？

但是，我首先想到的是用公式

　设g1为大于答案值的个数，g2是小于答案值的个数，s1是大于答案的每个数的总和，s2是小于答案的每个数的总和。同时，答案为x，能量损失为a。

　则有：（s1-h1*x）*a = h2*x - s2

　样例过了，但是好像有精度上的问题。

　

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

const int maxn=10000+10;

int n,k;
int shu[maxn];
int sum;
int sum1,sum2;
int g1,g2;
double pin,ans;

void readdate()
{
    cin>>n>>k;
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&shu[i]);
        sum+=shu[i];
    }
    sort(shu+1,shu+n+1);
    pin = (sum*1.0) / (n*1.0);　　//我们可以轻易证得，答案 < 所有数加起来的平均数，（因为有能量损失）
    for(int i=1;i<=n;i++)
    {
        if(shu[i]-pin>=0)
        {
            sum1+=shu[i];
            g1++;
        }
        else
        {
            sum2+=shu[i];
            g2++;
        }
    }
    return ;
}

void work()
{
    double a=(100-k)*0.01;
    ans=(a*sum1 + sum2*1.0)/(g2*1.0 + g1*a);
    printf("%.9lf\n",ans);
}

int main()
{
    readdate();
    work();
    return 0;
}

 

 

 

其次，我才想到了二分答案。

首先读入每个数，在读的时候要特判，如果读进去的数都是一样的，或者n==1，即只有一个值，那我们就可以直接输出了。

然后读完了所有数后，要进行sort排序，我是按照从大到小排序的，讲二分的 l 设为数列里最小的，r 设为最大的。因为是double型，有精度问题，所以while循环的条件就是（r-l）> 10^-12 ,然后就是常规取mid了。这个地方，check的条件也是十分明显的。首先把所有大于mid的数加起来（因为精度问题，也需要用（a-mid）> 10^-12 来判断大小），然后每次一个比它小的数，就从sum中减去，如果不够了，就说明我们枚举的ans大了，这时候就r=mid，否则这个方案就是可行的，l=mid（同时我习惯于在这一步就把答案更新为l）。

 

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

const int maxn=10000+10;

int n,k;
double shu[maxn];
double l,r,mid;
double ans;
bool flag;

bool cmp(double x,double y)
{
    return x>y;
}

void readdate()
{
    cin>>n>>k;
    for(int i=1;i<=n;i++)
    {
        scanf("%lf",&shu[i]);
        if(shu[i] != shu[i-1])
            flag=true;
    }
    if(!flag || n==1)　　//特判
    {
        printf("%.9f\n",shu[1]);
        exit(0);
    }
    sort(shu+1,shu+1+n,cmp);
    l=shu[n];
    r=shu[1];
}

bool check(double now)
{
    double sum1=0,sum2=0;
    for(int i=1;i<=n;i++)
    {
        if(shu[i]-now>=1e-12)
        {
            sum1+=(shu[i]-now);
        }
        else
        {
            double jian=(now-shu[i])*100.0 / (100.0 - k);　　//因为有能量损失，所以减掉需要的能量时，要除以能量损失百分比。为了精度，我上下同时乘以了一个100.
            if(jian-sum1>1e-12)
            {
                return false;
            }
            else
            {
                sum1-=jian;
            }
        }
    }
    return true;
}

void work()
{
    while(r-l>1e-12)
    {
        mid=(r+l)/2.0;
        if(check(mid))
        {
            ans=mid;
            l=mid;
        }
        else
        {
            r=mid;
        }
    }
    printf("%.9f\n",ans);
}

int main()
{
    readdate();
    work();
    return 0;
}

 

 

 

---

---

---

 

 

第三道题，很明显的一个最长上升子序列嘛。注意的条件不就是要判断两个相邻值之间项数差值是否大于d，以及注意数据范围，用nlogn的方法求最长上升子序列就可以了。我用的是之前在一道题解里看到过得求上升子序列的方法，正好有一个q的数组可以来判断d的关系。

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

const int maxn=100000+10;

int n,d,tot;
int q[maxn];
int c[maxn];
int s[maxn];

int main()
{
    while(scanf("%d%d",&n,&d)!=EOF)
    {
        tot=0;
        memset(c,0x3f3f3f,sizeof(c));　　//初始化为极大值
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&s[i]);
        }
        for(int i=1;i<=n;i++)
        {
            q[i]=lower_bound(c+1,c+1+n,s[i])-c;　　 //找到第一个大于等于s[i]的数，q存的就是当前第i个数字所存的位置
            if(q[i]>tot)
                tot=q[i];　　　　//如果q[i]找到位置都大于答案了，就重新赋值答案tot
            int cha=i-d;　　　　//cha值表示当前这个点最近能够取得它之前的哪个点
            if(cha>0 && c[q[cha]]>s[cha])　　　　//如果cha>0，即表示i之前有可取的点。同时在答案序列c里，这个可取点所对应的位置的数要大于当前这个点的值，那么我们的重新赋值才有意义，可以为后来的点腾更多的空间
                c[q[cha]]=s[cha];　　　　//重新赋值q[cha]所对应的数列c的值
        }
        cout<<tot<<endl;
    }
    return 0;
}

 

 

 

 

---

---

---

 

 

至于第四道题嘛，洛谷上的大佬都讲得很清楚了，一个状压dp。

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

int floors[5200][15];
int f[5200];
int maps[15][15];
int n,m,st,en,va;
int ans=0x3f3f3f;

void clear()
{
    memset(floors,0,sizeof(floors));
    memset(f,0x3f3f,sizeof(f));
}

void work(int k)
{
    int N=1<<n;
    f[1<<k]=0;
    floors[(1<<k)][k]=1;
    for(int i=0;i<N;i++)
        for(int j=0;j<n;j++)
            if((i & (1<<j))>0)
                for(int w=0;w<n;w++)
                    if(((i & (1<<w))==0) && (maps[j][w]!=-1))
                    {
                        int r=(1<<w);
                        int wi=f[i] + floors[i][j]*maps[j][w];
                        if(f[i+r] > wi)
                        {
                            f[i+r]=wi;
                            for(int l=0;l<n;l++)
                                floors[i+r][l]=floors[i][l];
                            floors[i+r][w]=floors[i][j]+1;
                        }
                    }
    ans=min(ans,f[N-1]);        
}

int main()
{
    memset(maps,-1,sizeof(maps));
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&st,&en,&va);
        if(maps[st-1][en-1]>va || maps[st-1][en-1]==-1)
            maps[st-1][en-1]=maps[en-1][st-1]=va;
    }
    for(int i=0;i<n;i++)
    {
        clear();
        work(i);
    }
    cout<<ans<<endl;
    return 0;
}