2017.5.13阶段模拟考试

预计分数:100+50(其实感觉自己写的对)+100

实际分数:100+0+100

 

P1149 火柴棒等式

 

题目描述

给你n根火柴棍，你可以拼出多少个形如“A+B=C”的等式？等式中的A、B、C是用火柴棍拼出的整数（若该数非零，则最高位不能是0）。用火柴棍拼数字0-9的拼法如图所示：

注意：

1. 加号与等号各自需要两根火柴棍

2. 如果A≠B，则A+B=C与B+A=C视为不同的等式（A、B、C>=0）

3. n根火柴棍必须全部用上

输入输出格式

输入格式：

输入文件matches.in共一行，又一个整数n（n<=24）。

输出格式：

输出文件matches.out共一行，表示能拼成的不同等式的数目。

输入输出样例

输入样例#1：

样例输入1：
14
样例输入2：
18

输出样例#1：

样例输出1：
2
样例输出2：
9

说明

【输入输出样例1解释】

2个等式为0+1=1和1+0=1。

【输入输出样例2解释】

9个等式为：

0+4=4
0+11=11
1+10=11
2+2=4
2+7=9
4+0=4
7+2=9
10+1=11
11+0=11

思路：上来先看了一眼数据范围，n<=24,打表！！
　　　然后读了读题，发现这是一个暴力求解的题目，但是想了想老师应该不会出这么水的题(事实证明高估老师了)，于是想了一会儿高端做法
无解。so还是暴力吧，n<=24,暴力了一下发现当i=2088的时候(此时需要25根)是不满足条件的。但是2088^3很明显超时啊，。。。一个点就
要跑17s+。。。但是别忘了n<=24!!!!!17s又不是太长、、在我做完第三题之前肯定能跑完吧，二话不说打表！

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;
int a[10001]={0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,8,9,6,9,29,39,38,65,88,128};
int ed=0;
int main()
{
    int n;
    scanf("%d",&n);
    cout<<a[n];
    return 0;
}

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;
int a[10001]={6,2,5,5,4,5,6,3,7,6,8};
int ed=0;
int p;

int main()
{
    freopen("debug.in","r",stdin);
    freopen("debug.out","w",stdout);
    for(int l=0;l<=24;l++)
    {
        int n;
        scanf("%d",&n);
        for(int i=10;i<9000;i++)
        {
            p=i;
            int tot=0;
            while(p!=0)
            {
                tot=tot+a[(p%10)];
                p=p/10;
            }
            a[i]=tot;
            if(tot>24)
            {
                ed=i;
                break;
            }
        }
        //for(int i=0;i<9000;i++)
        //    cout<<i<<" "<<a[i]<<endl;
        n=n-4;
        int ans=0;
        for(int i=0;i<ed;i++)
        {
            for(int j=0;j<ed;j++)
            {
                for(int k=0;k<ed;k++)
                {
                    if(i+j==k&&(a[i]+a[j]+a[k]==n))
                    {
                        //printf("%d+%d=%d\n",i,j,k);
                        ans++;
                    }
                }
            }
        }
        printf("%d %d\n",l,ans);
    }
        
    
    return 0;
}

 

P1113 杂务

题目描述

John的农场在给奶牛挤奶前有很多杂务要完成，每一项杂务都需要一定的时间来完成它。比如：他们要将奶牛集合起来，将他们赶进牛棚，为奶牛清洗乳房以及一些其它工作。尽早将所有杂务完成是必要的，因为这样才有更多时间挤出更多的牛奶。当然，有些杂务必须在另一些杂务完成的情况下才能进行。比如：只有将奶牛赶进牛棚才能开始为它清洗乳房，还有在未给奶牛清洗乳房之前不能挤奶。我们把这些工作称为完成本项工作的准备工作。至少有一项杂务不要求有准备工作，这个可以最早着手完成的工作，标记为杂务1。John有需要完成的n个杂务的清单，并且这份清单是有一定顺序的，杂务k(k>1)的准备工作只可能在杂务1..k-1中。

写一个程序从1到n读入每个杂务的工作说明。计算出所有杂务都被完成的最短时间。当然互相没有关系的杂务可以同时工作，并且，你可以假定John的农场有足够多的工人来同时完成任意多项任务。

输入输出格式

输入格式：

第1行：一个整数n，必须完成的杂务的数目(3<=n<=10,000)；

第2 ~ n+1行： 共有n行，每行有一些用1个空格隔开的整数，分别表示：

• 工作序号(1..n,在输入文件中是有序的)；

• 完成工作所需要的时间len（1<=len<=100）；

• 一些必须完成的准备工作，总数不超过100个，由一个数字0结束。有些杂务没有需要准备的工作只描述一个单独的0，整个输入文件中不会出现多余的空格。

输出格式：

一个整数，表示完成所有杂务所需的最短时间。

输入输出样例

输入样例#1：

7
1 5 0
2 2 1 0
3 3 2 0
4 6 1 0
5 1 2 4 0
6 8 2 4 0
7 4 3 5 6 0

输出样例#1：

23

思路：
错解：读完题立马想到拓扑排序（事实证明我掉坑里了，坑是那种能爬出来的那种），于是暴力写完拓扑排序但是发现这题有个坑，就是当
两件任务同时做的时候，如果他们的时间差太多，那么可以让耗时短的那个先继续往下做能做的来等那个耗时长的。。。。。然后就是DFS+
各种标记。后来自己造了几个数据发现还能过。。。。
然而
zero=.=

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<queue>
using namespace std;
const int MAXN=10001;
int n,meiyong,spend;
int rudu[MAXN];
int mst=0;
struct node
{
    int u,v,nxt;
}edge[MAXN];
int num=1;
int head[MAXN];
int maxnspend;//记出当前环节时间最长的任务的时间
int vis[MAXN];// 记录节点是否被删除 
int w[MAXN];// 记录每一个节点所需要的花费 
int flag[MAXN];
int ans=0;
int how=0;
void dfs(int now,int maxns,int spendnow)
{
    for(int i=head[now];i!=-1;i=edge[i].nxt)
    {
        spendnow+=w[edge[i].v];
        int will=edge[i].v;
        if(rudu[will]==1&&spendnow<=maxns)
        {
            flag[will]=1;
            dfs(will,maxns,spendnow);
        }
        spendnow-=w[edge[i].v];
    }
}
void topsort()
{
    queue<int>q;

    for(int i=1;i<=n;i++)
        if(rudu[i]==0)
            q.push(i);    
    while(q.size()!=0)
    {
        how++;
        int p=q.front();
        q.pop();
        maxnspend=-1;
        for(int i=head[p];i!=-1;i=edge[i].nxt)
        {
            if(flag[edge[i].v]==0)
                maxnspend=max(maxnspend,w[edge[i].v]);
        }
        int flag2=0;// 默认需要干 
        for(int i=head[p];i!=-1;i=edge[i].nxt)
        {
            int to=edge[i].v;
            rudu[to]--;
            if(rudu[to]==0)
            {
                dfs(to,maxnspend,w[edge[i].v]);
                q.push(to);
                if(w[to]!=maxnspend)
                {
                    flag[to]=1;
                }
                else if(w[to]==maxnspend&&flag2==1)flag[to]=1; 
                else flag2=1;
            }
            
        }
        if(flag[p]==0)
        ans=ans+w[p];
    }
    printf("%d",ans);
}
int main()
{
    //freopen("","r",stdin);
    //freopen("","w",stdout);
    
    scanf("%d",&n);
    for(int i=1;i<=n;i++)head[i]=-1;
    for(int i=1;i<=n;i++)
    {
        scanf("%d%d",&meiyong,&spend);
        w[meiyong]=spend;
        while(scanf("%d",&mst))
        {
            if(mst==0)break;
            rudu[meiyong]++;
            edge[num].u=mst;
            edge[num].v=meiyong;
            edge[num].nxt=head[mst];
            head[mst]=num++;
        }
    }
    topsort();
    return 0;
}

正解：这明显是一道关键路径问题，(说好的不考呢。。。)，但是不会也没关系，因为他有很多解法。
　　　1.因为题目让着求能完成的最小值。。。其实这句话的关键不是在最小值。而是在能完成！so如果每一个点都选择时间最大的那个
去做的话一定能完成。然后就是去枚举每一个点，去求能到达它的最大值，最后再在每一个点的最大值中取一个最大的！！

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<queue>
using namespace std;
const int MAXN=100001;
int n,meiyong;
int rudu[MAXN];
int mst=0;
struct node
{
    int u,v,nxt;
}edge[MAXN];
int num=1;
int head[MAXN];
int w[MAXN];
int spend[MAXN];
void topsort()
{
    queue<int>q;
    for(int i=1;i<=n;i++)
        if(rudu[i]==0)
            q.push(i),spend[i]=w[i];
    while(q.size()!=0)
    {
        int p=q.front();
        q.pop();
        for(int i=head[p];i!=-1;i=edge[i].nxt)
        {
            int to=edge[i].v;
            rudu[to]--;
            if(rudu[to]==0)
                q.push(to);
                spend[to]=max(spend[to],spend[edge[i].u]+w[edge[i].v]);
        }
    }
    int ans=-1;
    for(int i=1;i<=n;i++)
    ans=max(ans,spend[i]);
    printf("%d",ans);
}
int main()
{
    //freopen("","r",stdin);
    //freopen("","w",stdout);
    
    scanf("%d",&n);
    int s=0;
    for(int i=1;i<=n;i++)head[i]=-1;
    for(int i=1;i<=n;i++)
    {
        scanf("%d%d",&meiyong,&s);
        w[meiyong]=s;
        while(scanf("%d",&mst))
        {
            if(mst==0)break;
            rudu[meiyong]++;
            edge[num].u=mst;
            edge[num].v=meiyong;
            edge[num].nxt=head[mst];
            head[mst]=num++;
        }
    }
    topsort();
    return 0;
}

　　　　　2.假设我们不用拓扑排序，那我们可以记录出每一个最晚出现的位置，因为最晚出现的话其他的任务一定能完成，然后不断的贪最晚的就好

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int MAXN=100001;
int meiyong,v;
int k;
int dp[MAXN];
int ans=-1;
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%d%d",&meiyong,&v);
            while(scanf("%d",&k))
            {
                if(k==0)break;
                dp[i]=max(dp[i],dp[k]);
            }
        dp[i]+=v;
    }
    //printf("%d",dp[n]);
    for(int i=1;i<=n;i++)
    {
        ans=max(ans,dp[i]);
    }
    printf("%d",ans);
    return 0;
}

 

P2782 友好城市

题目背景

无

题目描述

有一条横贯东西的大河，河有笔直的南北两岸，岸上各有位置各不相同的N个城市。北岸的每个城市有且仅有一个友好城市在南岸，而且不同城市的友好城市不相同。没对友好城市都向政府申请在河上开辟一条直线航道连接两个城市，但是由于河上雾太大，政府决定避免任意两条航道交叉，以避免事故。编程帮助政府做出一些批准和拒绝申请的决定，使得在保证任意两条航道不相交的情况下，被批准的申请尽量多。

输入输出格式

输入格式：

第1行，一个整数N（1<=N<=5000），表示城市数。

第2行到第n+1行，每行两个整数，中间用一个空格隔开，分别表示南岸和北岸的一对友好城市的坐标。（0<=xi<=10000）

输出格式：

仅一行，输出一个整数，表示政府所能批准的最多申请数。

输入输出样例

输入样例#1：

7
22 4
2 6
10 3
15 12
9 8
17 17
4 2

输出样例#1：

4

说明

1<=N<=5000,0<=xi<=10000

思路：原题啊，把南边的排一遍序，然后求北面的最长上升子序列

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;
const int MAXN=5001;
int n;
struct node
{
    int x,y;
}a[MAXN];
int comp(const node &a ,const node & b)
{
    return a.x<b.x;
}
int dp[MAXN][4];
int tot=0;
int ans=1;
void dfs(int p)
{
    if(dp[p][3]!=0)
    {
        tot++;
        dfs(dp[p][3]);
    }
    ans=max(ans,tot);
}
int main()
{
    //freopen("","r",stdin);
    //freopen("","w",stdout);
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
        scanf("%d%d",&a[i].x,&a[i].y),dp[i][2]=0x7fff;
    sort(a+1,a+n+1,comp);
    for(int i=1;i<=n;i++)
        dp[i][1]=a[i].y;
    for(int i=1;i<=n;i++)// 每一个节点 
    {
        for(int j=i-1;j>=1;j--)// 它之前的节点 
        {
            if(dp[i][1]>=dp[j][1])
            {
                if(dp[i][1]<=dp[j][2])
                {
                    dp[j][2]=dp[i][1];
                    dp[j][3]=i;
                }
            }
        }
    }
    for(int i=1;i<n;i++)
    {
        tot=1;
        if(dp[i][2]!=0x7fff)
        {
            tot++;
            dfs(dp[i][3]);
        }
        
    }
    printf("%d",ans);
    return 0;
}

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
const int MAXN=5001;
struct node
{
    int north;
    int south;
}a[MAXN];
int comp(const node & a ,const node & b)
{
    return a.north<b.north;
}
int ans[MAXN];
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
        scanf("%d%d",&a[i].north,&a[i].south);
    sort(a+1,a+n+1,comp);
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=i-1;j++)
        {
            if(a[j].south<a[j+1].south)
            {
                ans[i]=max(ans[i],ans[j]+1);
            }
        }
    }
    printf("%d",ans[n]+1);
    return 0;
}

 

总结：
这次考试，，怎么说呢？，，成绩一般，但是自我感觉还可以，因为没有出现因为低级错误而失分的情况。而且第一题能想到
用打表做，说明考试经验有了一定的提升。第二题做错了就是做错了，也没什么好懊悔的。只能说明自己能力不够。

这次考试也反映出了最近学习的一些弊端，就是像做动规题的时候，很少能够深入的研究一个题，感觉自己做不出来，就去看题解
这样的话，就大大降低了对题目的把握能力。以至于在考试的时候，能想到一个看似对，但实际上暴零的题解。

顺便吐槽一下，，考试之前我可是认真的准备了线段树，KMP，树状数组，扩展欧几里得，高难度搜索的题目。。。
结果居然一个都没考。。。。。。。。。。。。。

%>_<%