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;
}
174
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
