C++博客-雪黛依梦-随笔分类-动态规划

hdu 1160 简单题

雪黛依梦 — Sun, 22 Aug 2010 03:24:00 GMT

//解题思路：根据题意，要输出的是排序之前的序号，所以将要处理的数据都存入一个结构体中
//首先利用qsort对weight进行快排
//剩下的问题就是从已排好的数组中找到最长下降子列（speed），并且输出这个子列的长度和子列中的元素的下标

#include
#include

struct mouse
{
  int w;
  int s;
  int cn;
}node[1001];

int cmp (const void *a, const void *b)  //一定要注意指针的指向是结构体     mouse
{
    if ( (*(mouse *)a).w != (*(mouse *)b).w )    //体重不等时对体重进行排序
    return  (*(mouse *)a).w - (*(mouse *)b).w;

    else if ( (*(mouse *)a).w == (*(mouse *)b).w )
    return  (*(mouse *)b).s - (*(mouse *)a).s;  //反之对速度进行降序排序
}

int main ()
{

    //输入数据
    int levl = 1;
    while (scanf ("%d%d", &node[levl].w, &node[levl].s) != EOF)
    {
          node[levl].cn = levl;
          levl ++;
    }

    //快排
    qsort ( node, levl, sizeof(node[0]), cmp );

    //对speed 按降序找到最长的子串:
    //用数组F[i]记录以i为起点的满足条件的子列长度，显然初始时为1;
    //用rout[i]记录搜索到最长子串的路径，把路径的下标存入到index[]中
    //max记录到当前为止子列的最长长度，end 记录到当前为止最长子列的最后一个下标
    int  F[1001];
    for (int i = 1; i < levl; i ++)
    {
        F[i] = 1;
    }
    int rout[1001];
    for (int i = 1; i < levl; i ++)
    {
        rout[i] = i;
    }

    int max = 1;  int end = 1;
    for (int i = 2; i < levl; i ++)
    {
        for (int j = 1; j < i; j ++)
        {
            if (node[j].s > node[i].s)
            {
               if (F[j] + 1 > F[i])   //现在长度增加1要 > 当前F[i] 才能产生作用
               {
                        F[i] = F[j] + 1;
                        rout[i] = j;                    //记录找到最下降序列的路径（即下标标号）
               }
            }
        }

       if ( F[i] > max )  //当前记录的长度大于 >  max时
        {
                max = F[i];
                end = i;
        }
    }

    printf ("%d\n", max);

    int index[1001];
    for (int i = 0; i < max; i ++)             //将路径记录到数组index[]中
    {
        index[max - i - 1] = end;
        end = rout[end--];
    }

    for ( int i = 0; i < max; i ++)
    {
        printf ("%d\n", node[index[i]].cn);
    }
   // system ("pause");
    return 0;
}

雪黛依梦 2010-08-22 11:24 发表评论

hdu 1466 DP 直线的可能交点数目

雪黛依梦 — Sun, 15 Aug 2010 02:02:00 GMT

//思路：分析易知递推关系式：dp[i][j] = （i - r）* r + dp[r][k]     // r条自由线和i - r条平行线的交点数 +   r条直线本身的交点数
//        dp[i][j]表示 i 条直线可能的交点种数 j = (i - r）* r + dp[r][k]
//        r表示自由线的条数，（i - r）表示平行线的条数，（i - r）* r 表示平行线和自由线的交点个数
//        r 可以取 0 -- i - 1 但是这里初始化的缘故循环时 r 取 1 -- i - 1
//        dp[r][k]表示 r 条直线本身的交点个数
//        max i 条直线最多的交点数
//        先把i条直线0个交点的情况初始值为1(这是一定的)，然后若i-r条直线有j个交点则i条直线必有（i-r）*r+j个交点，标记为 1
//        通过标记为 1 的下标 j 为 n 取 i 时的交点数
本题的巧妙之处在于：将下标对应为交点种类输出，同时又满足了从小到大输出这个条件

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main ()
{
    int dp[21][191];

    memset (dp, 0 , sizeof (dp));

    for (int i = 0; i < 21; i ++)
    {
        for (int j = 0; j < 191; j ++)
        {
            dp[i][0] = 1;          //0个交点的情况初始值为1
        }
    }

    dp[1][0] = 1;      //递归出口

    for (int i = 2; i < 21; i ++)
    {
        for (int r = 1; r < i; r ++)
        {
            for (int j = 0; j < 191; j ++)  //20条直线最多交点数为 190
            {
                if (dp[i - r][j] == 1)  //递归思想：如果 r 条直线存在交点数 j (这里 i - r 保证了r 可以取到 1 至 i - 1，即有dp[r][k])
                dp[i][j + (i - r) * r] = 1;  //则i条直线必有（i-r）*r+j(j 即dp[r][k])个交点，标记为 1
            }
        }
    }


    int n;
    while (scanf ("%d", &n) != EOF)
    {
          printf ("%d",0);
          int max = n * (n - 1) / 2;
          for (int j = 1; j <= max; j++)
          {
              if (dp[n][j])
              printf (" %d",j);
          }
          printf ("\n");
    }

    return 0;
}

雪黛依梦 2010-08-15 10:02 发表评论

hdu 1087 DP

雪黛依梦 — Sat, 14 Aug 2010 13:35:00 GMT

//本题是在 grids 2757的基础上得到解决的，即找到最大子例的和
// sum[i] 用于存放到 i 位置为止的子序列的和,所以只需要找到前i - 1 中的sum 所存的最大值再加上本身就可以了

#include <stdio.h>
#include <stdlib.h>

int main ()
{
    int b[1001];
    int n;
    __int64 sum[1001];  //用于存放到 i 位置为止的子序列的和

    while (scanf ("%d", &n) && n)
    {

          for ( int i = 0; i < n;i ++)
          {
              scanf ("%d", &b[i]);
          }

          sum[0] = b[0];
          for (int i = 1; i < n; i ++)               //下面的处理和 grids      2757的处理思想是一样的，只不过sum 数组存的是和值
          {
              int tempMaxsum = 0;
              for (int j = 0; j < i; j ++)     //因为 i 之前的和值已经存储在了sum中，
                                               // 所以只需要找到最大的tempMaxSum后再加上 i 位置本身的值就可以了
              {
                  if (b[j]                   {
                           tempMaxsum = sum[j];
                  }
              }

              sum[i] = tempMaxsum + b[i];

          }

          __int64 max = -1;
          for (int i = 0; i < n; i ++)
          {
              if (max < sum[i])
              {
                      max = sum[i];
              }

          }
          printf ("%I64d\n",max);

    }

    return 0;
}

雪黛依梦 2010-08-14 21:35 发表评论

grids 2757 求最大子例长度

雪黛依梦 — Sat, 14 Aug 2010 07:38:00 GMT

//动态规划题目最重要的一点是如何将问题分解得到子问题，并且将子问题解决
//本题以下标为状态量，找到以该下标位置 i 为终点时的最长子列：如果 i 位置的值 > i - 1位置的值，则长度加 1 ，
//所以利用判断大小来递归，出口是：下表为 0 时，长度为 1
//利用 nMaxLen【i】记录长度避免了重复计算

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main ()
{
    int n;
    int b[1000];
    int nMaxLen[1000];
    while (scanf ("%d", &n) != EOF && 1 <= n && n <= 1000)
    {
          memset (nMaxLen, 0 ,sizeof(nMaxLen));
          //将输入的数值存入数组 b 中
          for (int i = 0; i < n; i ++)
          {
              scanf ("%d", &b[i]);
          }

          //找到每一个状态下标 i 对应的最大子列长度，并将其存入数组nMaxLen[]中
          nMaxLen[0] = 1;
          for (int i = 1; i < n; i ++)
          {
              int temp = 0;
              for (int j = 0; j < i ; j ++)
              {
                  if ( b[i] > b[j])
                  {
                       if (temp < nMaxLen[j])          //只有当当前的长度 <  之前一位数的序列长时才可以赋值，最后起到 temp + 1 的作用
                                                                                            // 为什么:最大序列可能出现在 j 之后如： 7    9    10     6     11
                       temp = nMaxLen[j];
                  }
              }
              nMaxLen[i] = temp + 1;
          }

          //遍历数组nMaxLen从中读出最大值，即：在该位置时取得最大的子序列
          int max = -1;
          for (int i = 0; i < n; i ++)
          {
              if (nMaxLen[i] > max)
              max = nMaxLen[i];
          }

          printf ("%d\n", max);
    }
    //system ("pause");
    return 0;
}

雪黛依梦 2010-08-14 15:38 发表评论

hdu 2050 折线分割平面

雪黛依梦 — Mon, 09 Aug 2010 10:08:00 GMT

重点：http://hi.baidu.com/%BA%B2%C4%AB%C7%F3%CA%AF/blog/item/95f5fd2d8a40a8321f308984.html

1#include <stdio.h>
2#include <stdlib.h>
3int main ()
4{
5    int n, i, num;
6
7    while ( scanf ("%d", &i) != EOF )
8    {
9          for (int j = 0; j < i; j++)
10          {
11              num = 0;
12              scanf ("%d", &n);
13              num = 2 * n * n - n + 1;
14              printf ("%d\n", num);
15          }
16    }
17    return 0;
18}
19

思路：分析易知直线分割平面的关系：an= (n*n + n + 2) / 2;

拓展：曲线分割平面
问题的提出：
设有n条封闭曲线画在平面上，而任何两条封闭曲线恰好相交于两点，且任何三条封闭曲线不相交于同一点，问这些封闭曲线把平面分割成的区域个数。
F(1)=2
F(n)=F(n-1)+2(n-1)

雪黛依梦 2010-08-09 18:08 发表评论