洛谷 P1095 守望者的逃离

题目描述

恶魔猎手尤迪安野心勃勃，他背叛了暗夜精灵，率领深藏在海底的娜迦族企图叛变。守望者在与尤迪安的交锋中遭遇了围杀，被困在一个荒芜的大岛上。为了杀死守望者，尤迪安开始对这个荒岛施咒，这座岛很快就会沉下去。到那时，岛上的所有人都会遇难。守望者的跑步速度为17m/s，以这样的速度是无法逃离荒岛的。庆幸的是守望者拥有闪烁法术，可在1s内移动60m，不过每次使用闪烁法术都会消耗魔法值10点。守望者的魔法值恢复的速度为4点/s，只有处在原地休息状态时才能恢复。

现在已知守望者的魔法初值M，他所在的初始位置与岛的出口之间的距离S，岛沉没的时间T。你的任务是写一个程序帮助守望者计算如何在最短的时间内逃离荒岛，若不能逃出，则输出守望者在剩下的时间内能走的最远距离。注意：守望者跑步、闪烁或休息活动均以秒(s)为单位，且每次活动的持续时间为整数秒。距离的单位为米(m)。

输入输出格式

输入格式：
输入文件escape.in仅一行，包括空格隔开的三个非负整数M, S, T。

输出格式：
输出文件escape.out包含两行：

第1行为字符串“Yes”或“No”（区分大小写），即守望者是否能逃离荒岛。

第2行包含一个整数。第一行为“Yes”（区分大小写）时表示守望者逃离荒岛的最短时间；第一行为“No”（区分大小写）时表示守望者能走的最远距离。

输入输出样例

输入样例#1：
【输入样例1】
39 200 4
【输入样例2】
36 255 10
输出样例#1：
【输出样例1】
No
197
【输出样例2】
Yes
6
说明

30%的数据满足：1 <= T <= 10, 1 <= S <= 100

50%的数据满足：1 <= T <= 1000, 1 <= S <= 10000

100%的数据满足：1 <= T <= 300000, 0 <= M <= 1000, 1 <= S <= 10^8.

首先用搜索强行理解逻辑

搜索就是对每一秒分三种情况
第一种是奔跑；
第二种是闪烁；
第三种是恢复；
当然搜索肯定会超时的 ，但是根据搜索出来的树 ，不难发现一个规律
对每秒，距离最大的最优越。但是也有情况就是法师的闪烁是时间段才能产生优越的结果。
这时候就需要记录两个值。

然后我们算一个函数
奔跑速度为每秒钟17米
10点魔法闪现60米
5秒恢复20点魔法 闪现120米 ，就是只用魔法七秒120米
每秒平均17.14米。
但是初始的时候魔能是满状态的。
所以魔能的使用是最优越的。
只使用魔能一定比较快。
但是这样想，时间并不足够使用魔能。

所以要三种情况同时考虑。
但是三种情况用搜索的话，会产生很多重复的运算。
比如先闪现，和先奔跑，还有先奔跑和先闪现是一样的，但是搜索是搜所有情况，这样对于深度足够大的时候，重复的次数就会变得非常的多。
所以我们只需要一个简单的循环，就可以把搜索模拟出来而且不会出现重复情况。
我们优先一个人只用魔法，然后另外一个人只奔跑。
对于每秒钟留下移动距离最大的人。
因为移动速度是每秒17米 闪烁平均速度是每秒17.14米。
优先闪烁 ，所以一个人只闪烁并不会影响总体结果的最优性。

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <queue>
#include <cmath>
#include <stdlib.h>
using namespace std;
const int maxn=10000000;
int mint;
int maxs,z;
void dfs(int n,int m,int t)
{
    //cout<<n<<' '<<m<<' '<<t<<endl;
    if(t<mint) return ;
    if(m<=0)//代表到达
    {
        z=1;
        if(t>mint) mint=t;
        return ;
    }
    if(t==0)//代表到达不了的最大距离
    {
        if(m<maxs) maxs=m;
        return ;
    }
    dfs(n,m-17,t-1);//代表奔跑
    if(n>=10)  dfs(n-10,m-60,t-1);//代表闪现
    dfs(n+4,m,t-1);//代表恢复
}

int main()
{
    int n,m,t;
    while(cin>>n>>m>>t)
    {
        z=0;
        mint=0;
        maxs=maxn;
        dfs(n,m,t);
        if(z)
        {
            cout<<"Yes"<<endl;
            cout<<t-mint<<endl;
        }
        else
        {
            cout<<"No"<<endl;
            cout<<m-maxs<<endl;
        }

    }
}

优化后的搜索 依然超时，但是快得多

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <queue>
#include <cmath>
#include <stdlib.h>
using namespace std;
const int maxn=10000000;
int mint;
int maxs,z;
void dfs(int n,int m,int t)
{
    //cout<<n<<' '<<m<<' '<<t<<endl;
    if(t<mint) return ;
    if(m<=0)
    {
        z=1;
        if(t>mint) mint=t;
        return ;
    }
    if(t==0)
    {
        if(m<maxs) maxs=m;
        return ;
    } 
    if(n>=10)  dfs(n-10,m-60,t-1);
    else 
    { 
        dfs(n,m-17,t-1);
        dfs(n+4,m,t-1);
    }
}

int main()
{
    int n,m,t;
    while(cin>>n>>m>>t)
    {
        z=0;
        mint=0;
        maxs=maxn;
        dfs(n,m,t);
        if(z)
        {
            cout<<"Yes"<<endl;
            cout<<t-mint<<endl;
        }
        else
        {
            cout<<"No"<<endl;
            cout<<m-maxs<<endl;
        }

    }
}

可能有人会这样优化，只保留最大的。
但是这样的解法肯定是错误的，
因为对于闪烁，是平均每秒17.14，但是是7秒足够才能发挥出来的。
所以- -，只保留每秒的最大也是错误的。

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <queue>
#include <cmath>
#include <stdlib.h>
using namespace std;
const int maxn=10000000;
int mint;
int maxs,z;
int d[10000000];
void dfs(int n,int m,int t)
{
    //cout<<n<<' '<<m<<' '<<t<<endl;
    if(m>d[t]) return ;
    if(m<d[t]) d[t]=m;
    if(t<mint) return ;
    if(m<=0)
    {
        z=1;
        if(t>mint) mint=t;
        return ;
    }
    if(t==0)
    {
        if(m<maxs) maxs=m;
        return ;
    } 
    if(n>=10)  dfs(n-10,m-60,t-1);
    else 
    { 
        dfs(n,m-17,t-1);
        dfs(n+4,m,t-1);
    }
}

int main()
{
    int n,m,t;
    while(cin>>n>>m>>t)
    {
        memset(d,100,sizeof(d));
        z=0;
        mint=0;
        maxs=maxn;
        dfs(n,m,t);
        if(z)
        {
            cout<<"Yes"<<endl;
            cout<<t-mint<<endl;
        }
        else
        {
            cout<<"No"<<endl;
            cout<<m-maxs<<endl;
        }

    }
}

这个是贪心的代码。
非本人原创，但是用搜索理解了这个解法的原理

#include<iostream>
using namespace std;
int quantity,s,time;
int main()
{
    cin>>quantity>>s>>time;
    int s1=0,s2=0,time1=time;
    while(s>s1 && time>0)
    {
        s1+=17;
        if(quantity>=10) s2+=60,quantity-=10;
        else quantity+=4;
        s1=max(s1,s2);
        time--;
    }
    if(s1<s)
    cout<<"No"<<endl<<s1;
    else
    cout<<"Yes"<<endl<<time1-time;
    return 0;
}