G - 免费馅饼 （dp+记忆化搜索）

都说天上不会掉馅饼，但有一天gameboy正走在回家的小径上，忽然天上掉下大把大把的馅饼。说来gameboy的人品实在是太好了，这馅饼别处都不掉，就掉落在他身旁的10米范围内。馅饼如果掉在了地上当然就不能吃了，所以gameboy马上卸下身上的背包去接。但由于小径两侧都不能站人，所以他只能在小径上接。由于gameboy平时老呆在房间里玩游戏，虽然在游戏中是个身手敏捷的高手，但在现实中运动神经特别迟钝，每秒种只有在移动不超过一米的范围内接住坠落的馅饼。现在给这条小径如图标上坐标： 

为了使问题简化，假设在接下来的一段时间里，馅饼都掉落在0-10这11个位置。开始时gameboy站在5这个位置，因此在第一秒，他只能接到4,5,6这三个位置中其中一个位置上的馅饼。问gameboy最多可能接到多少个馅饼？（假设他的背包可以容纳无穷多个馅饼） 

Input

输入数据有多组。每组数据的第一行为以正整数n(0<n<100000)，表示有n个馅饼掉在这条小径上。在结下来的n行中，每行有两个整数x,T(0<T<100000),表示在第T秒有一个馅饼掉在x点上。同一秒钟在同一点上可能掉下多个馅饼。n=0时输入结束。 

Output

每一组输入数据对应一行输出。输出一个整数m，表示gameboy最多可能接到m个馅饼。 
提示：本题的输入数据量比较大，建议用scanf读入，用cin可能会超时。 
 

Sample Input

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

Sample Output

4

题意：中文题就不说了
注意初始化，初始化的数据要不和你运算后可能得到的结果相同，不然就可能会超时，我就在这TLE一发。
详见代码
用记忆化搜索dfs(x, y)表示在x时刻y位置得到的最大馅饼数。
转移方程 dfs(x, y) = max( dfs(x-1, tmp) ); ( |tmp-y| <= 1, 也就是可以从tmp位置一步到y位置) 
代码：

//Full of love and hope for life

#include <iostream>
#include <algorithm>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <queue>
#define inf 0x3f3f3f3f
//https://paste.ubuntu.com/

using namespace std;

typedef long long ll;
const ll maxn=100010;

int dp[maxn][11];//dp[i][j]表示i时刻j位置最多能得到的馅饼数
int flag[maxn][11];//flag[i][j]表示i时刻j位置掉的馅饼数
int nex[3]={1,0,-1};

int dfs(int x,int y){
    if(dp[x][y]!=-1){
        return dp[x][y];
    }
    int ans=-inf;
    if(x==0){
        if(y==5){
            return 0;
        }
        return -inf;
    }
    for(int i=0;i<3;i++){
        int t=nex[i]+y;
        if(t>=0&&t<=10){
            ans=max(ans,dfs(x-1,t));
        }
    }
    ans+=flag[x][y];
    return dp[x][y]=ans;
}
/*
void debug(int a){
   for(int i=0;i<=a;i++){
       for(int j=0;j<11;j++){
            if(j==10){
                cout << dp[i][j];
            }
            else{
                cout << dp[i][j] << " ";
            }
       }
       cout << endl;
   }
}
*/
int main(){
    ios::sync_with_stdio(false);//可能会超时
    int a;
    while(cin >> a){
        if(a==0){
            break;
        }
        int t=0;
        memset(flag,0,sizeof(flag));
        for(int i=0;i<a;i++){
            int x,y;
            cin >> x >> y;
            t=max(t,y);
            flag[y][x]++;
        }
        for(int i=0;i<=t;i++){
            for(int j=0;j<11;j++){
                dp[i][j]=-1;//初始化位-1，如果是0，可能那个时刻那个位置得到的馅饼数为0，
                                //本来计算了，会把它判成没有算的，增加运算量
            }
        }
        int ma=0;
        for(int i=0;i<11;i++){//求temp时刻所得到的馅饼数最多为多少
            ma=max(ma,dfs(t,i));
        }
        //debug(t);
        cout << ma << endl;
    }
    return 0;
}

#include <bits/stdc++.h>
#define MAXN 100010
using namespace std;

int dp[MAXN][12],n[MAXN][12];
//全局变量和静态变量的存储区域是在一起的，程序结束后由系统释放。数据区的大小由系统限定，一般很大。
int max_is(int a,int b,int c)
{
    return max(a,max(b,c));
}
int main()
{
    int a,x,t,i,j,maxt;
    while(scanf("%d",&a)!=EOF&&a)
    {
        memset(dp,0,sizeof(dp));
        memset(n,0,sizeof(n));
        maxt=0;
        for(i=0; i<a; i++)
        {
            scanf("%d%d",&x,&t);
            n[t][x]++;
            if(maxt<t) maxt=t;
        }
        for(i=1; i<=11; i++)
            dp[maxt][i]=n[maxt][i];
        for(i=maxt-1; i>=0; i--)
        {
            for(j=0; j<11; j++)
            {
                if(j==0) dp[i][j]=max(dp[i+1][j],dp[i+1][j+1])+n[i][j];
                else dp[i][j]=max_is(dp[i+1][j-1],dp[i+1][j],dp[i+1][j+1])+n[i][j];
            }
        }
        printf("%d\n",dp[0][5]);
    }
    return 0;
}

#include <stdio.h>
#include <memory.h>
#include <string.h>
#include <algorithm>
#include <queue>
#define INF 0x3f3f3f3f
#define ll long long
using namespace std;
int dp[11][100001],a[11][100001];
int main()
{
    int n,i,x,y,j,t,ans;
    while(scanf("%d",&n)&&n!=0)
    {
        memset(dp,0,sizeof(dp));
        t=-1;
        for(i=0; i<n; i++)
        {
            scanf("%d%d",&x,&y);
            dp[x][y]++; //地点时间
            t=max(t,y);//最长时间
        }
        for(i=t-1;i>=0;i--)
        {
            for(j=0;j<=10;j++)
            {
                ans=dp[j][i+1];
                if(j-1>=0)
                ans=max(ans,dp[j-1][i+1]);
                if(j+1<=10)
                ans=max(ans,dp[j+1][i+1]);
                dp[j][i]+=ans;
            }
        }
        printf("%d\n",dp[5][0]);
    }
    return 0;
}