过河

【问题描述】

在河上有一座独木桥，一只青蛙想沿着独木桥从河的一侧跳到另一侧。在桥上有一些石子，青蛙很讨厌踩在这些石子上。由于桥的长度和青蛙一次跳过的距离都是正整数，我们可以把独木桥上青蛙可能到达的点看成数轴上的一串整点：0，1，……，L（其中L是桥的长度）。坐标为0的点表示桥的起点，坐标为L的点表示桥的终点。青蛙从桥的起点开始，不停的向终点方向跳跃。一次跳跃的距离是S到T之间的任意正整数（包括S,T）。当青蛙跳到或跳过坐标为L的点时，就算青蛙已经跳出了独木桥。

题目给出独木桥的长度L，青蛙跳跃的距离范围S,T，桥上石子的位置。你的任务是确定青蛙要想过河，最少需要踩到的石子数。
【输入文件】

输入文件river.in的第一行有一个正整数L（1 <= L <= 10⁹），表示独木桥的长度。第二行有三个正整数S，T，M，分别表示青蛙一次跳跃的最小距离，最大距离，及桥上石子的个数，其中1 <= S <= T <= 10，1 <= M <= 100。第三行有M个不同的正整数分别表示这M个石子在数轴上的位置（数据保证桥的起点和终点处没有石子）。所有相邻的整数之间用一个空格隔开。
【输出文件】

输出文件river.out只包括一个整数，表示青蛙过河最少需要踩到的石子数。
【样例输入】
10
2 3 5
2 3 5 6 7
【样例输出】
2
【数据规模】
对于30%的数据，L <= 10000；
对于全部的数据，L <= 10 ⁹。

【算法分析】 （0502）

此题的动态规划方程较明显,设f[k]表示跳到点k必须踩到石子的个数,设p为青蛙跳的步数（即长度）,那么青蛙（从k-p）跳到k,若点k有石子,则f[k]=f[k-p]+1,否则为f[k]=f[k-p],可以用数组a表示点k处是否有石子,若有, a[k]为1,那么f[k]=f[k-p]+ a[k],而p满足：s<=p<=t

所以,规划方程为:f[k]=min{f[k-p]+a[k]}
                (k>=s;s<=p<=t)
由于青蛙可以跳到桥头也可以跳出桥,所以min{f[k]}即为所求.
                                       (L<=k<L+T)

算法(1):直接进行动态规划.这样做,空间复杂度为O(L),时间复杂度为O((t-s)*(L+T)≈O(L)
        而L最大值为10^9,显然无法承受.

算法(2):观察数据范围可知M很小,而L很大,所以,一定有很多空白的长条,在这段没有石子的线段上,会有很多个状态完全一样,那么可以进行压缩：

考虑12345678910+空长条,S=9,T=10根据DP方程可知后面一定是1234567891 1234567811 1234567111 1234561111......1211111111 1111111111这样,后面的会一直以"1"重复,直到遇到石子,那么从12345678910~1111111111共需要10*9=90个点,所以,如果有一段长条长度超过90,就可以减为90(=T*S),更科学地，可减为
INT(（T-1）/(T-S)+0.5)*T=(2*T-S-2)/(T-S)*T

算法(3):设T=10,若有一段"1111111111"后面有空白长条,那么,后面一定是1的循环,因为无论从几开始跳都是以1开始,所以，若某一状态值重复的长度若超过T,则直接跳到有石子的地方

需要注意的是对于s=t的情况要特殊讨论。

初始化:长度[1,s)的范围内,青蛙是跳不到的,所以必须设为无穷大（=M）,否则后面计算时可能会从这些状态转移到其他不可能的状态.

 

#include<stdio.h>
int S,T,M,a[10000],f[10000],d[101],max,sol;
long L,array[101];

void init()  /* 数据读入 */ 
{
  int i;
  scanf("%ld%d%d%d",&L,&S,&T,&M);
  array[0]=-1;
  for(i=1;i<=M;i++)
    scanf("%ld",&array[i]);
}
void select(long a[], int count)   /* 将石子出现的位置排序 */
{
  int i,j,temp;
  for(i=0;i<count;i++)         
  {
    temp=a[i];
    j=i-1;
    while(j>=0 && temp<a[j])
    {
      a[j+1]=a[j];
      j--;
    }
    a[j+1]=temp;
  }
}
/* 求空长条的长度，并压缩空长条 */
/* 从第1颗石子开始压缩，若第1颗石子的位置与青蛙能跳的最小步长S之差大于max,则应压缩，压缩量d=array[1]-array[0]-max,更新array[1]的值:  array[1]=array[1]-d; 从第二颗石子（i>=2)开始，若第i颗石子位置与第i-1颗石子位置（注意第i-1颗石子位置在上一轮循环中更新了，更新量为d）之差大于d+max,则应压缩第i-1与第i颗石子间的空条子，更新总压缩量d的值：d=array[i]-array[i-1]-max，若否则不要压缩，总压缩量d保持原值不变；不论是否压缩，都应更新array[i]的值:array[i]=array[i]-d;(因为d不为0)。若令array[0]=S,d=0,则第1颗石子也适用以上规则。  */
void blank()
{
  int i;
  long d=0;
  array[0]=S;
  for(i=1;i<=M;i++)
  {
    if(d<array[i]-array[i-1]-max)
      d=array[i]-array[i-1]-max; 
    array[i]=array[i]-d;
  }
}
void dbf()
{
  int i,j;
  memset(a, 0, sizeof(a));
  for(i=1;i<=M;i++)a[array[i]]=1; /* 用数组a标记桥上哪些位置（是压缩后更新的位置）有石子 */
  /*  以下动态规划求数组f的值  */ 
  f[0]=0;     /* 初始化 */ 
  for(i=1;i<array[M]+T;i++) f[i]=100;  /* 初始化 */ 
  for(i=S;i<=T;i++) f[i]=a[i];
  for(i=T+1;i<array[M]+T;i++)   /* 压缩后，青蛙跳到array[M] 至 array[M]+T-1的任一位置就算过桥了 */ 
  {
    for(j=i-T;j<=i-S;j++)
      if(f[i]>f[j]+a[i]) f[i]=f[j]+a[i];
  }
  /* 以下求最后结果 */ 
  sol=100;
  for(i=array[M];i<array[M]+T;i++)
    if(f[i]<sol)sol=f[i];//求结果
}

int main() 
{
  int k;
 
  init();
  if(T==S)
  {
    sol=0;  /* T=S的情形，直接计算  */ 
    for(k=1;k<=M;k++)
      if(array[k]%T==0)sol++;
  }
  else
  { 
    max=(2*T-S-2)/(T-S);
    max=max*T;
    select(array,M+1);
    blank();
    dbf();
  }
  printf("%d\n",sol);  
  return 0;
}