周总结（链式前向星，洛谷）

电脑坏了就很离谱，我的操作中心都打不开了，自己重装了下系统，花了很长时间才装好，然后office也给我整没了，我又花了很长时间破解了下。还误把java作业给整没了，幸亏邮箱里大部分都有备份。
在我做数据结构的时候求关键路径的时候，觉得用简单的邻接表和邻接矩阵做起来题很麻烦的，然后就查资料，发现了用vecter和链式前向星来储存图。看完后直呼厉害。

链式前向星在另一篇博客 传送（链式前向星）

然后刷了洛谷题
刷的dp题，有的题在上学期的acm课程作业上大同小异。
P1280 尼克的任务
尼克每天上班之前都连接上英特网，接收他的上司发来的邮件，这些邮件包含了尼克主管的部门当天要完成的全部任务，每个任务由一个开始时刻与一个持续时间构成。

尼克的一个工作日为 nn 分钟，从第 11 分钟开始到第 nn 分钟结束。当尼克到达单位后他就开始干活，公司一共有 kk 个任务需要完成。如果在同一时刻有多个任务需要完成，尼克可以任选其中的一个来做，而其余的则由他的同事完成，反之如果只有一个任务，则该任务必需由尼克去完成，假如某些任务开始时刻尼克正在工作，则这些任务也由尼克的同事完成。如果某任务于第 pp 分钟开始，持续时间为 tt 分钟，则该任务将在第 (p+t-1)(p+t−1) 分钟结束。

写一个程序计算尼克应该如何选取任务，才能获得最大的空暇时间。

思路：若从前往后遍历，后面的事件会影响前面的事件，所以从后向前遍历，这个题之前貌似做过，可能见过差不多的

#include <bits/stdc++.h>
using namespace std;
#define ll long long
const int maxn=0x3f3f3f;
int n,k;
struct node{
    ll p,t;
};
bool cmp(node a,node b){
    return a.p>b.p;
}
ll ans[10005];
ll dp[10005];
ll num=0;
int main(){
    memset(ans,0,sizeof(ans));
    memset(dp,0,sizeof(dp));
    cin>>n>>k;
    node a[10005];
    for(int i=0;i<k;i++){
        cin>>a[i].p>>a[i].t;
        ans[a[i].p]++;
    }
    sort(a,a+k,cmp);
    for(int i=n;i>=1;i--){
        if(ans[i]==0)
            dp[i]=dp[i+1]+1;
    else{
        for(int j=1;j<=ans[i];j++){
            if(dp[i+a[num].t]>dp[i])
                dp[i]=dp[i+a[num].t];
                num++;
            }
        }
    }
    cout<<dp[1]<<endl;
    return 0;
}

P1279 字串距离
设有字符串 XX，我们称在 XX 的头尾及中间插入任意多个空格后构成的新字符串为 XX 的扩展串，如字符串 XX 为abcbcd，则字符串abcb□cd，□a□bcbcd□和abcb□cd□ 都是 XX 的扩展串，这里□代表空格字符。

如果 A_1A
1
​
是字符串 AA 的扩展串，B_1B
1
​
是字符串 BB 的扩展串，A_1A
1
​
与 B_1B
1
​
具有相同的长度，那么我们定义字符串 A_1A
1
​
与 B_1B
1
​
的距离为相应位置上的字符的距离总和，而两个非空格字符的距离定义为它们的 ASCII 码的差的绝对值，而空格字符与其他任意字符之间的距离为已知的定值K，空格字符与空格字符的距离为 00。在字符串 AA、BB 的所有扩展串中，必定存在两个等长的扩展串 A_1A
1
​
，B_1B
1
​
，使得 A_1A
1
​
与 B_1B
1
​
之间的距离达到最小，我们将这一距离定义为字符串 AA，BB 的距离。

请你写一个程序，求出字符串 AA，BB 的距离。
思路：
dp[i][j]表示a中前i个字符和b中前j个字符在加上空后一样长度后的最小距离
dp[i][j]=min(dp[i][j],min(dp[i][j-1]+k,min(dp[i-1][j]+k,dp[i-1][j-1]+abs(a[i]-b[j]))));

#include <bits/stdc++.h>
using namespace std;
const int maxn=0x3f3f3f;
int a[2005],b[2005];
int dp[2005][2005];
int main(){
    string str1,str2;
    cin>>str1>>str2;
    int k;
    cin>>k;
    memset(dp,25,sizeof(dp));
    for(int i=0;i<str1.size();i++){
        a[i+1]=int(str1[i]);
        dp[i][0]=i*k;
    }
    for(int i=0;i<str2.size();i++){
        b[i+1]=int(str2[i]);
        dp[0][i]=i*k;
    }
    dp[0][0]=0;
    for(int i=1;i<=str1.size();i++)
    for(int j=1;j<=str2.size();j++){
        dp[i][j]=min(dp[i][j],min(dp[i][j-1]+k,min(dp[i-1][j]+k,dp[i-1][j-1]+abs(a[i]-b[j]))));
    }
    cout<<dp[str1.size()][str2.size()];

    return 0;
}

P1133 教主的花园
教主有着一个环形的花园，他想在花园周围均匀地种上n棵树，但是教主花园的土壤很特别，每个位置适合种的树都不一样，一些树可能会因为不适合这个位置的土壤而损失观赏价值。

教主最喜欢33种树，这3种树的高度分别为10,20,3010,20,30。教主希望这一圈树种得有层次感，所以任何一个位置的树要比它相邻的两棵树的高度都高或者都低，并且在此条件下，教主想要你设计出一套方案，使得观赏价值之和最高。
思路：需要考虑这个树与傍边树的高低

dp[i][0][0]=max(dp[i-1][2][1],dp[i-1][1][1])+a[i][0]; 
dp[i][1][0]=dp[i-1][2][1]+a[i][1];
dp[i][1][1]=dp[i-1][0][0]+a[i][1];
dp[i][2][1]=max(dp[i-1][0][0],dp[i-1][1][0])+a[i][2];

dp[i][0][0]=表示第前i个树种高度为10且比旁边的树的低的最大观赏值
dp[i][1][0]=表示第前i个树种高度为20且比旁边的树的低的最大观赏值
dp[i][1][1]=表示第前i个树种高度为20且比旁边的树的高的最大观赏值
dp[i][2][0]=表示第前i个树种高度为20且比旁边的树的高的最大观赏值
因为是个环，所以i等于0是需要特判
代码：

#include <bits/stdc++.h>
using namespace std;
int dp[100005][4][2],a[100005][4];
int main(){
    int n;
    cin>>n;
    for(int i=0;i<n;i++)
        cin>>a[i][0]>>a[i][1]>>a[i][2];
    for(int i=1;i<n;i++){
        dp[i][0][0]=max(dp[i-1][2][1],dp[i-1][1][1])+a[i][0];
        dp[i][1][0]=dp[i-1][2][1]+a[i][1];
        dp[i][1][1]=dp[i-1][0][0]+a[i][1];
        dp[i][2][1]=max(dp[i-1][0][0],dp[i-1][1][0])+a[i][2];
    }
    dp[0][0][0]=max(dp[n-1][2][1],dp[n-1][1][1])+a[0][0];
    dp[0][1][0]=dp[n-1][2][1]+a[0][1];
    dp[0][1][1]=dp[n-1][0][0]+a[0][1];
    dp[0][2][1]=max(dp[n-1][0][0],dp[n-1][1][0])+a[0][2];
    cout<<max(dp[0][0][0],max(dp[0][1][0],max(dp[0][1][1],dp[0][2][1])));
    return 0;
}