蓝桥杯 分分钟的碎碎念

问题描述：
    以前有个孩子，他分分钟都在碎碎念。不过，他的念头之间是有因果关系的。他会在本子里记录每一个念头，并用箭头画出这个念头的来源于之前的哪一个念头。翻开这个本子，你一定会被互相穿梭的箭头给搅晕，现在他希望你用程序计算出这些念头中最长的一条因果链。

  将念头从1到n编号，念头i来源于念头from[i]，保证from[i]<i，from[i]=0表示该念头没有来源念头，只是脑袋一抽，灵光一现。

输入格式：

  第一行一个正整数n表示念头的数量
  接下来n行依次给出from[1]，from[2]，…，from[n]

输出格式：

  共一行，一个正整数L表示最长的念头因果链中的念头数量

样例输入：

  8
  0
  1
  0
  3
  2
  4
  2
  4

样例输出:

  3

样例说明:

  最长的因果链有： 1->2->5 (from[5]=2,from[2]=1,from[1]=0)
           1->2->7 (from[7]=2,from[2]=1,from[1]=0)
           3->4->6 (from[6]=4,from[4]=3,from[3]=0)
           3->4->8 (from[8]=4,from[4]=3,from[3]=0)

数据规模和约定:

  字符串长度<=1000

思路解析：
 递归：
  使用递归的方法，从源头0开始依次寻找下一个念头，没找到一个念头，则数量+1，对于每一条念头链，比较当前念头链的的长度和最大念头链的长度。

 动态规划：
  建立一个与from数组等长的数组dp，dp[i]表示当前序号能满足构成的最长的长度，dp[i]的值可以由dp[from[i]]+1得到

代码：
  递归：

#include <iostream>
#include <string>
#include <cmath>
#include <vector>
#include <iomanip> 
#include <sstream>
#include <iomanip>
#include <algorithm>
using namespace std;

int n;
int a[1000];
int maxpath=0;

void digui(int index,int count)
{
	int i;
	for(i=1;i<=n;i++)
		if (a[i]==index) 
			digui(i,count+1);
	if(i==n+1)
		maxpath=max(maxpath,count);
}
int main()
{
    cin >> n;
	for(int i=0;i<n;i++)
		cin>>a[i];
	digui(0,0);
	cout<<maxpath<<endl;
}

  动态规划

#include<iostream>
#include<algorithm>
using namespace std;
int from[1001];
int dp[1001];
int main () {
    int n, ans = 0;
    cin >> n;
    for (int i = 1; i <= n; i++) {
        cin >> from[i];
    }
    for (int i = 1; i <= n; i++) {
        dp[i] = dp[from[i]] + 1;
        ans = max(dp[i], ans);
    }
    cout << ans<<endl;
    return 0;
}