NOIP模拟题 2016.8.29 [树相关问题] [数论] [贪心] [拓扑排序]

原创 2016年08月29日 16:53:38

A
描述(A 输入文件 : A.input 输出文件 : A.output)
一个城市的构成是一颗n 个节点的树(2 ≤ n ≤ 200), 现在需要在树中找出两条不相交的路
径(即两条路径不能有重边也不能有重点),使得路径的长度的乘积最大。
输入描述
第一行一个数n 表示这个城市一共有 n 个节点。
接下来 n-1 行,每行两个数ai 和bi (1 ≤ ai,bi ≤ n ),分别表示从ai 到bi,有一条边,每条边
的长度为1。
输出描述
输出一行一个数表示两条路径长度最大的乘积。
样例数据
样例输入1:
7
1 2
1 3
1 4
1 5
1 6
1 7
样例输出1:
0
样例输入2:
6
1 2
2 3
2 4
5 4
6 4
样例输出2:
4


B

描述(B 输入文件 : B.input 输出文件 : B.output)
有n 个人需要看医生, 其中第i 个人需要看医生的次数是ai, 一开始从1 到n 依次排列组成
一个等待队伍, 每个人依次看医生, 那么每个人看完医生有两种情况, 第一种情况:他
已经看够他需要看医生的次数,那么他会离开。第二种情况:他还需要看医生,那么他就
会选择重新站在队伍的最后。选择医生想知道,当他看过k 次病人之后,这个等待队伍是
什么样。
输入描述
第一行两个正整数 n 和 k (1 ≤ n ≤ 105, 0 ≤ k ≤ 1014)
第二行一共个n 正整数 a1, a2, …, an (1 ≤ ai ≤ 109),用空格隔开。
输出描述
一行,按队列的顺序输出需要的结果,每两个数之间用空格隔开,注意不要输出多余的空
格。数据保证此时队列里至少有一个人。
样例数据
样例输入1:
3 3
1 2 1
样例输出1:
2
样例输入2:
7 10
1 3 3 1 2 3 1
样例输出2:
6 2 3


C

描述(C 输入文件 : C.input 输出文件 : C.output)
有n 个任务需要你去完成,这些任务分布在3 个不同的房间,编号为1,2,3, 其中有些任务
必须在一些其他的任务完成之后才能完成。现在知道完成一个任务需要1 的时间,现在知
从房间1 到2,2 到3,3 到1 需要1 的时间,从1 到3,2 到1,3 到2 需要2 的时间。现
在你可以选择你一开始的房间,问完全所有任务的最短时间是多少,保证可以完成。
输入描述
第一行一个数 n (1 ≤ n ≤ 200) 。
第二行 n 个数, 第i 个数 ci (1 ≤ ci ≤ 3) 表示该任务所在的房间。.
接下来一共 n 行. 第 i 行的第一个数是 ki (0 ≤ ki ≤ n - 1),表示完成第i 个任务之前需要完
成的任务个数,之后 ki 个正整数表示需要提前完成的任务的编号。
输出描述
输出一个正整数表示完成任务需要是时间。
样例数据
样例输入1:
5
2 2 1 1 3
1 5
2 5 1
2 5 4
1 5
0
样例输出1:
7


A:
不是树形DP。。至少树形DP应该不好写。。
树形DP实际上是枚举点,而这道题要求点边不重复,那么枚举边就可以把树分成两部分,每一部分找出直径相乘即可。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<vector>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<string>
#include<iomanip>
#include<ctime>
#include<climits>
#include<cctype>
#include<algorithm>
#ifdef WIN32
#define AUTO "%I64d"
#else
#define AUTO "%lld"
#endif
using namespace std;
#define smax(x,tmp) x=max((x),(tmp))
#define smin(x,tmp) x=min((x),(tmp))
#define maxx(x1,x2,x3) max(max(x1,x2),x3)
#define minn(x1,x2,x3) min(min(x1,x2),x3)
const int INF=0x3f3f3f3f;
const int maxn = 205;
struct Edge
{
    int to,next;
}edge[maxn<<1];
int head[maxn];
int maxedge;
inline void addedge(int u,int v)
{
    edge[++maxedge] = (Edge) { v,head[u] };
    head[u] = maxedge;
    edge[++maxedge] = (Edge) { u,head[v] };
    head[v] = maxedge;
}
struct Road
{
    int u,v;
}road[maxn];
int n;
void init()
{
    scanf("%d",&n);
    memset(head,-1,sizeof(head));
    maxedge=-1;
    for(int i=1;i<n;i++)
    {
        int &u=road[i].u,&v=road[i].v;
        scanf("%d%d",&u,&v);
        addedge(u,v);
    }
}
int depth[maxn];
int bad;
void dfs(int u,int father,int deep,int &end)
{
    depth[u]=deep;
    if(!end || depth[end]<depth[u]) end=u;
    for(int i=head[u];~i;i=edge[i].next)
    {
        int v=edge[i].to;
        if(v==father || v==bad) continue;
        dfs(v,u,deep+1,end);
    }
}
void work()
{
    int ans=0;
    for(int i=1;i<n;i++)
    {
        int max1=0,max2=0;
        int end1=0,end2=0;
        bad=road[i].v;
        dfs(road[i].u,road[i].v,1,end1);
        dfs(end1,0,1,end2);
        max1=depth[end2]-1;
        end1=end2=0;
        bad=road[i].u;
        dfs(road[i].v,road[i].u,1,end1);
        dfs(end1,0,1,end2);
        max2=depth[end2]-1; 
        smax(ans,max1*max2);
    }
    printf("%d",ans);
}
int main()
{
    freopen("A.input","r",stdin);
    freopen("A.output","w",stdout);
    init();
    work();
    return 0;
}

B:
找规律,每一次操作都可以使最小的出列,剩下的顺序不变,那么找到这个恰好出列的人,然后剩下的取模后就可以模拟了。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<vector>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<string>
#include<iomanip>
#include<ctime>
#include<climits>
#include<cctype>
#include<algorithm>
#ifdef WIN32
#define AUTO "%I64d"
#else
#define AUTO "%lld"
#endif
using namespace std;
#define smax(x,tmp) x=max((x),(tmp))
#define smin(x,tmp) x=min((x),(tmp))
#define maxx(x1,x2,x3) max(max(x1,x2),x3)
#define minn(x1,x2,x3) min(min(x1,x2),x3)
typedef long long LL;
const int maxn = 100005;
LL n,k;
struct Data
{
    int order;
    LL val;
    bool operator < (const Data t) const
    {
        if(val ^ t.val) return val < t.val;
        return order < t.order;
    }
}a[maxn];
bool cmp(const Data a,const Data b)
{
    return a.order < b.order;
}
void init()
{
    scanf(AUTO AUTO,&n,&k);
    for(int i=1;i<=n;i++) scanf(AUTO,&a[i].val),a[i].order=i;
    sort(a+1,a+n+1);
}
int ans[maxn],cnt;
void work()
{
    LL last=0;
    int now=1;
    int tot=n;
    while(now<=n && k>=(a[now].val-last)*tot)
    {
        k-=(a[now].val-last)*tot;
        last = a[now].val;
        while(a[now].val==last)
        {
            tot--;
            if(now<n) now++;
            else break;
        }
    }
    sort(a+1,a+n+1,cmp);
    last+=k/tot;
    k%=tot;
    for(int i=1;i<=n;i++) if(a[i].val>last) ans[++cnt]=i;
    int pos=1+k;
    for(int i=pos;i<cnt;i++) printf("%d ",ans[i]);
    printf("%d",ans[cnt]);
    for(int i=1;i<pos;i++) if(a[ans[i]].val>last+1) printf(" %d",ans[i]);
}
int main()
{
    freopen("B.input","r",stdin);
    freopen("B.output","w",stdout);
    init();
    work();
    return 0;
}

C:
一来想DP,怎么想出很多方程最后被自己证明是错的。。。
然而边权只有1和2,顺时针1,反时针2,并且这题恰好反时针走等效于顺时针走2次,那么可以用三个队列来维护入度为0的点,每次贪心地处理,也就是说处理完所有当前盒子里的任务之后才到下一个box里去。这样可以达到最优的目的。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<vector>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<string>
#include<iomanip>
#include<ctime>
#include<climits>
#include<cctype>
#include<algorithm>
#ifdef WIN32
#define AUTO "%I64d"
#else
#define AUTO "%lld"
#endif
using namespace std;
#define smax(x,tmp) x=max((x),(tmp))
#define smin(x,tmp) x=min((x),(tmp))
#define maxx(x1,x2,x3) max(max(x1,x2),x3)
#define minn(x1,x2,x3) min(min(x1,x2),x3)
const int INF=0x3f3f3f3f;
const int maxn = 205;
struct Edge
{
    int to,next;
}edge[maxn*maxn];
int head[maxn];
int maxedge;
int in[maxn];
inline void addedge(int u,int v)
{
    edge[++maxedge] = (Edge) { v,head[u] };
    head[u] = maxedge;
    in[v]++;
}
int room[maxn];
int n;
void init()
{
    scanf("%d",&n);
    memset(head,-1,sizeof(head));
    maxedge=-1;
    for(int i=1;i<=n;i++) scanf("%d",room+i),room[i]--;
    for(int i=1;i<=n;i++)
    {
        int cnt;
        scanf("%d",&cnt);
        for(int j=1;j<=cnt;j++)
        {
            int tmp;
            scanf("%d",&tmp);
            addedge(tmp,i);
        }
    }
}
queue <int> que[3];
int deg[maxn];
int work(int S)
{
    int ans=0;
    int cnt=0;
    memcpy(deg,in,sizeof(in));
    for(int i=1;i<=n;i++) if(!in[i]) que[room[i]].push(i),cnt++;
    int cur=S;
    while(cnt)
    {
        while(!que[cur].empty())
        {
            int u=que[cur].front();que[cur].pop();cnt--;
            for(int i=head[u];~i;i=edge[i].next)
            {
                int v=edge[i].to;
                if(--deg[v]==0) que[room[v]].push(v),cnt++;
            }
        }
        if(!cnt) break;
        ans++; // goto another box
        cur++;
        if(cur>2) cur-=3;
    }
    return ans+n; // count the cost of every node 
}
int main()
{
    freopen("C.input","r",stdin);
    freopen("C.output","w",stdout);
    init();
    int ans=INF;
    for(int i=0;i<3;i++) smin(ans,work(i));
    printf("%d",ans);
    return 0;
}
版权声明:S'il vous plait.

相关文章推荐

NOIP模拟题[贪心][DP][数论]

改程序之前,写程序之前,确保自己理解了,不然效率会很低。 写程序少用复制黏贴,容易细节出错,不好调试。 T1: 题意: 给定两字符串,判断B串是否是A串的字串且输出B串每个字母的匹配位置字典序...

NOIP模拟题 River Path Word[排序][贪心][DP]

一.Word 题意:给定n个长度小于100的,全为大写字母的单词,求一共有多少种,判断是一种的标准是:两个单词中每个字母的个数都相同;n<=10000; 分析:只考虑字母个数则可以对一个单词中的字...

XJOI NOIP模拟题2[数论][组合数][树规]

今天玩得有点嗨,嗯冷静冷静。 考试策略很重要,时间分配啊难度的选择啊对拍啊都很重要。建议还是看一遍题,像今天觉得T1好写结果不知不觉卡很久,T3其实是写过的水题就这么没了。该开始复习数论了不然药丸,...

NOIP模拟题 2016.11.9 [动态规划] [数论] [二分答案] [启发式合并] [线段树] [树链剖分]

子序列 描述 给定3 个字符串,求它们的最长公共子序列。 输入 第一行一个整数n,表示三个字符串的长度 接下来三行,每行是一个长度为n 只包含小写字母的字符串。 输出 输出最长公共子序列...

NOIP模拟题 2016.11.17 [数论] [数位DP] [扫描线] [线段树]

T1: 题意:求[L,R]内素数的个数。预处理O(sqrt(n))个素数,然后筛法求素数,平移一下。#include #include #include #include #include #inc...

NOIP模拟题 2016.8.27 [贪心] [DP] [计数问题]

LGTB 与偶数 LGTB 有一个长度为N 的序列。当序列中存在相邻的两个数的和为偶数的话,LGTB 就能把它们删掉。 LGTB 想让序列尽量短,请问能将序列缩短到几个数? 输入 第一行包含一...

NOIP模拟题 2016.11.8 (2) [线段树] [动态逆序对] [矩阵快速幂] [数论] [欧拉函数]

T1: 题意:有一个序列,m次操作,每次操作指定一个位置,将当前位置和该位置后面所有比它小的数构成的子序列排序,放入原位置。求每次操作后,逆序对个数。首先在线做法不好做,那么考虑离线。 对于一个数...

NOIP模拟题 2016.11.4 [数论] [费马小定理] [最短路] [建图]

细胞分裂 【问题描述】 小A 养了一大坨细胞。 最初小A 只有1 个细胞。每秒,小A 的每个细胞都会分裂成2 个细胞。 已知:现在离“最初”已经过去了x 秒,那么现在的细胞数当然是可以计算的。...

NOIP模拟题 2016.9.3 [数论] [逆序对] [树状数组] [树形dp]

强迫症 问题描述 人行道铺着两行地砖,第一行每块的长度是A/B,第二行每块的长度是X/Y。两行砖块 第一块的一边是对齐的。 作为一个强迫症患者,看到这样的地砖你很不爽,于是就想知道,最少隔多少...

NOIP模拟题 2016.11.18 [数论] [计数] [并查集]

第一题:信(believe.cpp/c/pas) 背景描述: 一切死亡都有冗长的回声 —— 《一切》北岛 给定一个N个元素的序列A, 定义Bi = (Ai and A1) + (Ai and...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)