ACM 动态规划 D

Problem D

Time Limit : 2000/1000ms (Java/Other)   Memory Limit : 65536/32768K (Java/Other)
Total Submission(s) : 13   Accepted Submission(s) : 5

Problem Description

A number whose only prime factors are 2,3,5 or 7 is called a humble number. The sequence 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 15, 16, 18, 20, 21, 24, 25, 27, ... shows the first 20 humble numbers. <br><br>Write a program to find and print the nth element in this sequence<br>

Input

The
input consists of one or more test cases. Each test case consists of
one integer n with 1 <= n <= 5842. Input is terminated by a value
of zero (0) for n.<br>

Output

For
each test case, print one line saying "The nth humble number is
number.". Depending on the value of n, the correct suffix "st", "nd",
"rd", or "th" for the ordinal number nth has to be used like it is shown
in the sample output.<br>

Sample Input

1

2

3

4

11

12

13

21

22

23

100

1000

5842

0

Sample Output

The 1st humble number is 1.

The 2nd humble number is 2.

The 3rd humble number is 3.

The 4th humble number is 4.

The 11th humble number is 12.

The 12th humble number is 14.

The 13th humble number is 15.

The 21st humble number is 28.

The 22nd humble number is 30.

The 23rd humble number is 32.

The 100th humble number is 450.

The 1000th humble number is 385875.

The 5842nd humble number is 2000000000.

简单题意:

   就是一个数字的因子 只有 2 3 5 7 这几个数字, 求输出啊a[n]

思路分析:

    开始初始化前4个数字,后一个数字肯定是前几个数字的乘积,所以由前几个数字推出后面几个数字的dp方法,,

 

# include <iostream>
# include <vector>
using namespace std;
long long int a[6000];

long long int Min(long long int a, long long int b, long long int c, long long int d)
{
    if(a <= b && a <= c && a <= d) return a;
    if(b <= a && b <= c && b <= d) return b;
    if(c <= b && c <= a && c <= d) return c;
    if(d <= b && d <= c && d <= a) return d;
}

int main()
{
    a[1] = 1; a[2] = 2; a[3] = 3; a[4] = 4;
    int n = 1;
    int num2, num3, num5, num7;
    num2 = num3 = num5 = num7 = 1;
    while(n < 5842)
    {
        n++;
        a[n] = Min(2 * a[num2], 3 * a[num3], 5 * a[num5], 7 * a[num7]);
        if(a[n] == 2 * a[num2])
        num2++;
        if(a[n] == 3 * a[num3])
        num3++;
        if(a[n] == 5 * a[num5])
        num5++;
        if(a[n] == 7 * a[num7])
        num7++;
        //cout << a[n] << endl;
    }
    while(cin >> n)
    {
        if(n == 0)
        break;
        if(n % 10 == 1 && n % 100 != 11)
        cout << "The "<< n << "st humble number is " << a[n] << "." << endl;
        else if(n % 10 == 2 && n % 100 != 12)
        cout << "The "<< n << "nd humble number is " << a[n] << "." << endl;
        else if(n % 10 == 3 && n % 100 != 13)
        cout << "The "<< n << "rd humble number is " << a[n] << "." << endl;
        else
        cout << "The "<< n << "th humble number is " << a[n] << "." << endl;
    }

    return 0;
}
时间: 2024-10-28 20:43:41

ACM 动态规划 D的相关文章

【DP专辑】ACM动态规划总结

转载请注明出处,谢谢.   http://blog.csdn.net/cc_again?viewmode=list          ----------  Accagain  2014年5月15日 动态规划一直是ACM竞赛中的重点,同时又是难点,因为该算法时间效率高,代码量少,多元性强,主要考察思维能力.建模抽象能力.灵活度. 本人动态规划博客地址:http://blog.csdn.net/cc_again/article/category/1261899 ******************

cf 414B Mashmokh and ACM 动态规划

题目链接:http://codeforces.com/problemset/problem/414/B dp[i][j]表示长度为i.最后一个数字为j的合法序列总数 dp[1][1...2000]都是1 后面用dp[i-1][j] 去更新 dp[i][j*t] (1 <= j*t <= 2000) 即用因子去更新它的倍数 表面上看是2000^3的复杂度会爆 其实不用算那么多次 最外层循环是2000 分析第二层和第三层 需要算 2000/1 + 2000/2 + 2000/3 + 2000/4

ACM 动态规划 最大 m 子段和问题(课上)

Max Sum Plus Plus Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)Total Submission(s): 23976 Accepted Submission(s): 8199 Problem Description Now I think you have got an AC in Ignatius.L's "Max Sum" problem. To be

ACM 动态规划 最大路径得分(课上)

问题: 给定一个具有N层的数字三角形如下图,从顶至底有多条路径,每一步可沿左斜线向下或沿右斜线向下,路径所经过的数字之和为路径得分,请求出最大路径得分.        7        3 8     8 1 0   2 7 4 4   4 5 2 6 5 用到记忆化搜索的方式,可以增加效率,用递归算法太慢了... /* 课上题目 最大路径得分 */ # include <iostream> using namespace std; const int MAX = 1e4; int dp[MA

ACM 动态规划 最长上升子序列(课上)

输入数据 输入的第一行是序列的长度N (1 <= N <= 1000).第二行给出序列中的N 个整数,这些整数的取值范围都在0 到10000. 输出要求 最长上升子序列的长度. 输入样例 7 1 7 3 5 9 4 8 输出样例 4 /* 课上题目 最长上升子序列 */ # include <iostream> using namespace std; const int MAX = 1e5; int a[MAX + 10]; int len[MAX + 10]; int main

整数拆分问题的四种解法【转载】

http://blog.csdn.net/u011889952/article/details/44813593 整数拆分问题的四种解法 原创 2015年04月01日 21:17:09 标签: 算法 / 母函数定理 / 五边形数定理 / acm / 动态规划 整数划分问题是算法中的一个经典命题之一 所谓整数划分,是指把一个正整数n写成如下形式: n=m1+m2+m3+....+mi;(其中mi为正整数,并且1<=mi<=n),则{m1,m2,m3,....,mi}为n的一个划分. 如果{m1,

【转载转载转载!】整数拆分问题的四种解法--尼奥普兰

整数拆分问题的四种解法 原创 2015年04月01日 21:17:09 标签: 算法 / 母函数定理 / 五边形数定理 / acm / 动态规划 整数划分问题是算法中的一个经典命题之一 所谓整数划分,是指把一个正整数n写成如下形式: n=m1+m2+m3+....+mi;(其中mi为正整数,并且1<=mi<=n),则{m1,m2,m3,....,mi}为n的一个划分. 如果{m1,m2,m3,....,mi}中的最大值不超过m,即max{m1,m2,m3,....,mi} <= m,则称

[ACM] hdu 1260 Tickets (动态规划)

Tickets Time Limit : 2000/1000ms (Java/Other)   Memory Limit : 65536/32768K (Java/Other) Total Submission(s) : 4   Accepted Submission(s) : 2 Font: Times New Roman | Verdana | Georgia Font Size: ← → Problem Description Jesus, what a great movie! Thou

ACM:DAG上的动态规划------硬币问题

ExecutorService 建立多线程线程池的步骤: 线程池的作用: 线程池作用就是限制系统中执行线程的数量. 根据系统的环境情况,可以自动或手动设置线程数量,达到运行的最佳效果:少了浪费了系统资源,多了造成系统拥挤效率不高.用线程池控制线程数量,其他线程排队等候.一个任务执行完毕,再从队列的中取最前面的任务开始执行.若队列中没有等待进程,线程池的这一资源处于等待.当一个新任务需要运行时,如果线程池中有等待的工作线程,就可以开始运行了:否则进入等待队列. 为什么要用线程池: 1.减少了创建和