18.8.20 考试总结

铁塔
(tower.pas/c/cpp)
题目描述
Rainbow 和Freda 要在Poetic Island 市的一座山脚下盖房子定居了……盖房子需要钢材

，幸运的是，这里有排成一行的n 座废弃的铁塔，从左到右编号为1~n，其中第i 座的高度为h[i]。

Rainbow 和Freda 想盖一座上面小下面大的城堡，并且城堡的层数尽可能多。

因此，他们要把这些铁塔分成尽量多组，每组内的铁塔编号必须是连续的，并且从左到右各组内铁塔的高度之和单调不减。

最后，他们会用每组铁塔所提供的钢材构成一层城堡。但是 Rainbow 和Freda 简直弱爆了有木有，

于是请你帮忙计算一下最多能分成多少组呢？

 

输入格式
第一行一个整数n。

第二行 n 个整数，第i 个整数表示h[i]。

输出格式

输出一个整数，表示(n - 最多能分成的组数)。

 

这道题一开始我还以为是贪心 结果后来贪心是错的 然后就突然想到了dp是怎么搞的

然后dp[i]表示以1 ~ i 并且以第i个结尾的一段最多分为多少组

len[i]表示dp[i]对应的最后一组的高度之和是多少 维护一个前缀和

转移就是dp[i] = dp[j] + 1 (sum[i] - sum[j]) 表示j + 1 ~ i 分成一组

然后如果相等取len的min方便后面转移

代码

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>
#include <cmath>
using namespace std;
typedef long long ll;
const int N = 5000 + 10;
int n;
ll h[N],dp[N],len[N],sum[N];
int main( ) {
freopen("tower.in","r",stdin);
freopen("tower.out","w",stdout);
scanf("%d",& n);
for(int i = 1;i <= n;i ++) {
scanf("%I64d",& h[i]);
sum[i] = sum[i - 1] + h[i];
}
for(int i = 1;i <= n;i ++)
for(int j = 0;j < i;j ++) {
if(sum[i] - sum[j] >= len[j]) {
if(dp[j] + 1 > dp[i]) {
dp[i] = dp[j] + 1;
len[i] = sum[i] - sum[j];
}
else if(dp[j] + 1 == dp[i]) {
len[i] = min(len[i],sum[i] - sum[j]);
}
}
}
printf("%I64d",n - dp[n]);
}

工作计划

(work.pas/c/cpp)

题目描述

Mark 在无意中了解到了 Elf 的身世。在和 James 商量过之后，好心的他们打算送 Elf 返回故乡。

然而，去往 Gliese 的飞船票价高的惊人，他们暂时还付不起这笔费用。经过一番考虑，Mark 打算去额外做一些工作来获得收入。

经过一番调查，Mark 发现有 N 个工作可以做。做第 i 件工作所需要的时间为 Di，同时也需要一个能力值 Ci 才可以去做，

每件工作都可以在任意时间开始，也可以做任意多次。所有的工作给付的报酬都是一致的。同时，有 S 个课程可以参加，

我们认为今天是第 0 天，第 i 个课程在第 Mi 天开始，持续时间为 Li 天，课程结束之后能力值会变为 Ai。现在 Mark 的能力值为 1。

Mark 只能做工作到第 T 天（因为那是飞船起飞的日子）。

他想知道期限内他最多可以做多少件工作，好决定未来的打算。于是他找到你了 applepi。

でも、applepi は彼女と一緒に楽しむことが大切だ，所以这个任务就交给你了。

 

输入格式

第一行包含三个空格分隔的整数 T,S,N。

之后 S 行，每行三个整数 M,L,A，描述一个课程。

之后 N 行，每行两个整数 C,D，描述一件工作。

 

输出格式

一个整数，表示 Mark 最多可以做多少件工作。

 

这道题正解是dp 我复制一波题解

动态规划，定义f[i][j]代表在i时间，能力值为j的最多工作次数。

对应最后三种选择：

①不作为 f[i][j]=f[i-1][j],

②上课 f[i][j]=f[上课前一个时刻][任意],

③做工作 f[i][j]=f[i-po[j]][j]+1 （po[j]为能力值<=j的工作一次的最短用时）。

对于②可以在预处理出ke[i][j]在i时刻结束，能力值达到j的课程的最晚开始时间。dp过程中处理出g[i]=max{f[i][j]}。

g[t]即为答案。

然后考试的时候我写的搜索竟然A了... 我也不知道我那个复杂度是多少 就很迷

dp代码(yyyuuudalao的)

#include <cstdio>
#include <algorithm>
using namespace std ;
int dp[10005][105] ;
int Day ;
int N , M ;
int mnn[105] ;
int zjj[10005][105] ;
int fz[10005] ;
int main ( )
{
freopen ( "wrk.in" , "r" , stdin ) ;
freopen ( "wrk.out" , "w" , stdout ) ;
scanf ( "%d%d%d" , &Day , &M , &N ) ;
for ( int i = 0 ; i <= Day ; i++ )
for ( int j = 1 ; j <= 100 ; j++ )
zjj[i][j] = 1e9 ;
for ( int i = 1 ; i <= M ; i++ )
{
int s , l , u ;
scanf ( "%d%d%d" , &s , &l , &u ) ;
zjj[s+l][u] = min ( zjj[s+l][u] , l ) ;
}
for ( int i = 0 ; i <= 100 ; i++ ) mnn[i] = 1e9 ;
for ( int i = 1 ; i <= N ; i++ )
{
int s , t ;
scanf ( "%d%d" , &s , &t ) ;
mnn[s] = min ( mnn[s] , t ) ;
}
for ( int i = 1 ; i <= 100 ; i++ ) mnn[i] = min ( mnn[i] , mnn[i-1] ) ;
for ( int i = 0 ; i <= Day ; i++ )
for ( int j = 1 ; j <= 100 ; j++ )
dp[i][j] = -1e9 ;
dp[0][1] = 0 ;
for ( int i = 1 ; i <= Day ; i++ )
{
for ( int j = 1 ; j <= 100 ; j++ )
{
dp[i][j] = dp[i-1][j] ;
if ( zjj[i][j] != 1e9 ) dp[i][j] = max ( dp[i][j] , fz[i-zjj[i][j]] ) ;
if ( i - mnn[j] >= 0 ) dp[i][j] = max ( dp[i][j] , dp[i-mnn[j]][j] + 1 ) ;
fz[i] = max ( fz[i] , dp[i][j] ) ;
}
}
printf ( "%dn" , fz[Day] ) ;
}

蒟蒻的垃圾搜索代码

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>
#include <cmath>
using namespace std;
const int N = 100 + 5;
const int M = 1e5 + 5;
int t,s,n,mi[N],ans;
bool vis[M],name[M];
struct node {
int tim;
bool operator < (const node & a) const {
return tim > a.tim;
}
};
int w[N];
struct lesson{
int st,len,abi;
}l[N];
void dfs(int day,int abil,int min_tim,int wrk) {
if(day == t + 1) {
ans = max(ans,wrk); return ;
}
else if(day > t + 1) {
ans = max(ans,wrk - 1);
return ;
}
int mm = min_tim;
if(vis[day]) {
int id = name[day]; bool tag = false;
int cmp = max(abil,l[id].abi);
if(cmp == abil) tag = true;
if(! tag) {
min_tim = mi[cmp];
dfs(day + l[id].len,cmp,min_tim,wrk);
}
}
dfs(day + min_tim,abil,mm,wrk + 1);
}
int main( ) {
freopen("wrk.in","r",stdin);
freopen("wrk.out","w",stdout);
scanf("%d%d%d",& t,& s,& n);
for(int i = 1;i <= s;i ++) {
scanf("%d%d%d",& l[i].st,& l[i].len,& l[i].abi);
l[i].st ++; name[l[i].st] = i;
vis[l[i].st] = true;
}
memset(w,0x3f3f3f,sizeof(w));
for(int i = 1;i <= n;i ++) {
int cc,tt;
scanf("%d%d",& cc,& tt);
w[cc] = min(w[cc],tt);
}
memset(mi,0x3f3f3f,sizeof(mi));
for(int i = 1;i <= 100;i ++)
for(int j = 1;j <= i;j ++)
if(w[j] != 0)
mi[i] = min(mi[i],w[j]);
dfs(1,1,mi[1],0);
printf("%d",ans);
}

树洞
(holes.pas/c/cpp)
题目描述
在一片栖息地上有N棵树 ，每棵树下住着一只兔子 ，有 M条路径连接这些树。

更特殊地是，只有一棵树有3条或更多的路径与它相连，其它树只有1条或2条路径与它相连，

换句话讲，这些树和之间的构成一张 N个点、 M条边的无向连通图，而度数大于2的点至多有1个。

近年以来 ，栖息地频繁受到人类的侵扰。兔子们联合起来召开了一场会议， 决定在其中K棵树上建造洞。

当危险来临时，每只兔子均会同时前往距离最近的树洞躲避 ，路程中花费的时间在数值上等于距离。

为了在最短的时间内让所有兔子脱离危险，请你安排一种建造树洞的方式使最后一只到达树洞的兔子所花费的时间尽量少。

 

输入格式

第一行有 3个整数 N，M，K，分别表示树（兔子） 的个数 、路径数计划 建造的树洞数 。

接下来 M行每三个整数 x,y，表示第x棵树和第y棵树之间有一条路径相连。1<=x,y<=N，x≠y，任意两棵树之间至多只有1条路径。

 

输出格式

一个整数，表示在最优方案下后只到达树洞的兔子所花费时间 。

 

这道题还是挺难的 至少我在考试的时候并没有任何思路 然后下来听大佬们讲才懂得

这道题因为度数大于二的 点只有一个 所以他可以形成一个菊花（buhsi）图

一旦把菊花心给他割了(......??????? 剩下的东西肯定是几条链...

所以就二分最短的最长长度 也就是最后一只兔贼到树洞的时间

如何搞呢 就是先把菊花心在二分的长度内可以走到的点都打上标记

然后把剩下的链长度dfs搞一搞 对于每条链 他的需要的洞数量就是 链的长度 / (二分答案 * 2 + 1)

因为分母就是贪心的每一个洞覆盖的最长长度 然后这玩意儿要上取整

然而会出现最优方案并不会选到菊花心的问题 那么怎么搞呢 枚举菊花心可以走到的点

每次去选一选 就像上述一样搞一搞就可以了 

正确性是因为在这个范围内选的数 对于它的覆盖范围内的点都打上标记 剩下的仍然是若干条连

然而为什么一定要在范围内选呢 因为如果不在范围内选 菊花心就选不到就不合法了

然后剩下的情况就是没有菊花心 就是一条链

那就是(n - k) / (2 * k) 就是n个点里面选了剩下的点除以每个点覆盖范围上取整

 

代码(我调了特别久就是因为bfs里面起点没打标记 我恨...!!!!!)

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>
#include <cmath>
#define oo 1000000000
using namespace std;
const int N = 2000 + 5;
int n,m,k,now,rd[N],tot,head[N],nex[N * N],tov[N * N];
int dis[N][N],root;
bool vis[N];
queue<int>Q;
void add(int u,int v) {
tot ++;
tov[tot] = v;
nex[tot] = head[u];
head[u] = tot;
}
void bfs(int u) {
memset(vis,0,sizeof(vis));
Q.push(u);
vis[u] = true;
while(! Q.empty( )) {
int x = Q.front( );
Q.pop( );
for(int i = head[x];i;i = nex[i]) {
int v = tov[i];
if(! vis[v]) {
vis[v] = true; Q.push(v);
dis[u][v] = dis[v][u] = dis[u][x] + 1;
}
}
}
}
void dfs(int u) {
now ++; vis[u] = true;
for(int i = head[u];i;i = nex[i]) {
int v = tov[i];
if(! vis[v]) dfs(v);
}
}
int solve(int u,int len) {
int ans = 0;
memset(vis,0,sizeof(vis));
for(int i = 1;i <= n;i ++)
if(dis[u][i] <= len) vis[i] = true;
for(int i = 1;i <= n;i ++)
if(! vis[i]) {
now = 0;
dfs(i);
ans += ceil(1.0 * now / (2 * len + 1));
}
return ans;
}
bool check(int len) {
int aaa = oo;
for(int i = 1;i <= n;i ++)
if(dis[root][i] <= len)
aaa = min(aaa,solve(i,len));
int fuck=0;
if(aaa + 1<= k) fuck=1;
return fuck;
}
int main( ) {
freopen("holes.in","r",stdin);
freopen("holes.out","w",stdout);
scanf("%d%d%d",& n,& m,& k);
for(int i = 1;i <= m;i ++) {
int u,v;
scanf("%d%d",& u,& v);
add(u,v); add(v,u);
rd[u] ++; rd[v] ++;
}
for(int i = 1;i <= n;i ++) {
bfs(i); if(rd[i] > 2) root = i;
}
if(! root) root = 1;
int l = 1,r = n,ans = -1;
while(l <= r) {
int mid = (l + r) >> 1;
if(check(mid)) ans = mid,r = mid - 1;
else l = mid + 1;
}
cout << ans;
}

今天考的还可以..