C# 动态规划-龟兔赛跑

解决这个问题的关键在于是否选择充电，通过程序算出最优方案
下面是解决程序

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _龟兔赛跑
{
    class Program
    {
        static void Main(string[] args)
        {
            int L;
            L = Convert.ToInt32(Console.ReadLine());
            int N, C, T;
            string[] str = Console.ReadLine().Split(' ');
            N = Convert.ToInt32(str[0]);
            C = Convert.ToInt32(str[1]);
            T = Convert.ToInt32(str[2]);
            int VR, VT1, VT2;
            str = Console.ReadLine().Split(' ');
            VR = Convert.ToInt32(str[0]);
            VT1 = Convert.ToInt32(str[1]);
            VT2 = Convert.ToInt32(str[2]);
            int[] nN= new int[N];
            str = Console.ReadLine().Split(' ');
            for (int i = 0; i < N; i++)
                nN[i] = Convert.ToInt32(str[i]);
            int tzTime = L / VR;
            int wgTime = 0;
            int minTime;//最少时间
            //选择是否充电
            if (C >= L)//到第一个充电桩时间
                wgTime = L / VT1;
            else
            {
                if (C >= nN[0])
                    wgTime += nN[0] / VT1;
                else
                    wgTime += C / VT1 + (nN[0] - C) / VT2;
                for (int i = 0; i < N; i++)
                {
                    if(i==N-1)//如果是最后一个充电桩
                    {
                        if (L - nN[i] > C)
                        {
                            minTime = wgTime + T + C / VT1 + (L - nN[i] - C) / VT2;
                            if((wgTime+(L-nN[i])/VT2)<minTime)
                            {
                                minTime = wgTime + (L - nN[i]) / VT2;
                            }
                            wgTime = minTime;
                        }
                        else
                        {
                            minTime = wgTime + T + (L - nN[i]) / VT1;
                            if ((wgTime + (L - nN[i]) / VT2) < minTime)
                            {
                                minTime = wgTime + (L - nN[i]) / VT2;
                            }
                            wgTime = minTime;
                        }
                    }else if (nN[i + 1] - nN[i]>C)
                    {
                        if (nN[i+1] - nN[i] > C)
                        {
                            minTime = wgTime + T + C / VT1 + (nN[i + 1] - nN[i] - C) / VT2;
                            if ((wgTime + (nN[i + 1] - nN[i]) / VT2) < minTime)
                            {
                                minTime = wgTime + (nN[i + 1] - nN[i]) / VT2;
                            }
                            wgTime = minTime;
                        }
                        else
                        {
                            minTime = wgTime + T + (nN[i + 1] - nN[i]) / VT1;
                            if ((wgTime + (nN[i + 1] - nN[i]) / VT2) < minTime)
                            {
                                minTime = wgTime + (nN[i + 1] - nN[i]) / VT2;
                            }
                            wgTime = minTime;
                        }
                    }
                }
            }
            if (wgTime > tzTime)
                Console.WriteLine("Good job,rabbit!");
            else
                Console.WriteLine("What a pity rabbit!");
        }
    }
}