1-2-5组合问题的最高效完整算法

转载 2012年03月22日 18:48:22
        1-2-5组合问题的最高效完整算法       
94人阅读评论(3)收藏举报

问题描述:用1,2,5这三个数组合,和为N。1,2,5的个数自己定,求有多少种不同的组合方法?

  1. /************************************************************************
  2. ***By       : Summon                                                  ***
  3. ***Data     : 2010.01.17                                              ***
  4. ***Function : 1-2-5组合之和等于100,文总共有多少种                           ***
  5. ***           组合方式。                                                      ***
  6. ***Method   : 首先使用蛮力发,复杂度O(n^3/)                              ***
  7. ***           其次使用蛮力法的改进,复杂度O(n^2)                          ***
  8. ***           最后是超级算法,复杂度O(n)                            ***                                                                    
  9. /************************************************************************/ 
  10. #include "stdafx.h" 
  11. #include <stdio.h> 
  12. #include <stdlib.h> 
  13. #include <string.h> 
  14. #include <time.h> 
  15.  
  16. typedef int STATUS; 
  17.  
  18. STATUS FoolHardinessMethod(int N, int *result); 
  19. STATUS FoolHardinessMethodImproved(int N, int *result); 
  20. STATUS SuperMethod(int N, int *result); 
  21.  
  22. int main(int argc, char* argv[]) 
  23.     clock_t start; 
  24.     clock_t end; 
  25.     double realTime; 
  26.     int N; 
  27.  
  28.     printf("Please input the N!/n"); 
  29.     fflush(stdin); 
  30.     scanf("%d", &N); 
  31.  
  32.     int result = 0; 
  33.     start = clock(); 
  34.     FoolHardinessMethod(N, &result); 
  35.     end = clock(); 
  36.     realTime = ((double)(end - start))/CLOCKS_PER_SEC; 
  37.     printf("N= %d/n", N); 
  38.     printf("FoolHardinessMethod Running Time = %f/n", realTime); 
  39.     printf("result = %d/n", result); 
  40.     printf("/n");     
  41.  
  42.     start = clock(); 
  43.     FoolHardinessMethodImproved(N, &result); 
  44.     end = clock(); 
  45.     realTime = ((double)(end - start))/CLOCKS_PER_SEC; 
  46.     printf("N= %d/n", N); 
  47.     printf("FoolHardinessMethodImproved Running Time = %f/n", realTime); 
  48.     printf("result = %d/n", result); 
  49.     printf("/n"); 
  50.  
  51.     start = clock(); 
  52.     SuperMethod(N, &result); 
  53.     end = clock(); 
  54.     realTime = ((double)(end - start))/CLOCKS_PER_SEC; 
  55.     printf("N= %d/n", N); 
  56.     printf("SuperMethod Running Time = %f/n", realTime); 
  57.     printf("result = %d/n", result); 
  58.     printf("/n"); 
  59.  
  60.     return 1; 
  61.  
  62. STATUS FoolHardinessMethod(int N, int *result) 
  63.     if (result == NULL) 
  64.     { 
  65.         return 0; 
  66.     } 
  67.  
  68.     int N1 = N/1; 
  69.     int N2 = N/2; 
  70.     int N5 = N/5; 
  71.     *result = 0; 
  72.  
  73.     for (int i=0; i<=N5; i++) 
  74.     { 
  75.         for (int j=0; j<=N2; j++) 
  76.         { 
  77.             for (int k=0; k<=N1; k++) 
  78.             { 
  79.                 if (5*i + 2*j + k == N) 
  80.                 { 
  81.                     *result += 1; 
  82.                 } 
  83.             } 
  84.         } 
  85.     } 
  86.     return 1; 
  87.  
  88. STATUS FoolHardinessMethodImproved(int N, int *result) 
  89.     if (result == NULL) 
  90.     { 
  91.         return 0; 
  92.     } 
  93.  
  94.     int N2 = N/2; 
  95.     int N5 = N/5; 
  96.     *result = 0; 
  97.  
  98.     for (int i=0; i<=N5; i++) 
  99.     { 
  100.         for (int j=0; j<=N2; j++) 
  101.         { 
  102.             if (((N - 5*i - 2*j) >= 0) && ((N - 5*i - 2*j) <= N)) 
  103.             { 
  104.                 *result += 1;  
  105.             } 
  106.         } 
  107.     } 
  108.     return 1; 
  109.  
  110. STATUS SuperMethod(int N, int *result) 
  111.     if (result == NULL) 
  112.     { 
  113.         return 0; 
  114.     } 
  115.  
  116.     *result = 0; 
  117.      
  118.     for (int i=0; i<=N; i+=5) 
  119.     { 
  120.         *result += (i+2)/2; 
  121.     } 
  122.  
  123.     switch (N%5) 
  124.     { 
  125.     case 0:  
  126.         { 
  127.             break
  128.         } 
  129.     case 1: 
  130.         { 
  131.             *result += (1*(N - N%5))/10; 
  132.             break
  133.         } 
  134.     case 2: 
  135.         { 
  136.             *result += (2*(N - N%5))/10 + 1; 
  137.             break
  138.         } 
  139.     case 3: 
  140.         { 
  141.             *result += (3*(N - N%5))/10 + 1; 
  142.             break
  143.         } 
  144.     case 4:  
  145.         { 
  146.             *result += (4*(N - N%5))/10 + 2; 
  147.             break
  148.         } 
  149.     } 
  150.     return 1; 

1-2-5组合问题的最高效完整算法

问题描述:用1,2,5这三个数组合,和为N。1,2,5的个数自己定,求有多少种不同的组合方法?/****************************************************...
  • lzy0001sl
  • lzy0001sl
  • 2010年01月17日 16:11
  • 1017

排列组合和回溯算法-面试题

排列组合和回溯算法的面试题
  • sunxianghuang
  • sunxianghuang
  • 2016年07月13日 15:02
  • 1948

字符串匹配最高效的算法

例如,在拼写检查、语言翻译、数据压缩、搜索引擎、网络入侵检测、计算机病毒特征码匹配以及DNA序列匹配等应用中,都需要进行字符串匹配: 先预处理查找模式串首字符在主串中的所有出现位置,并将其保存在...
  • zxc110110
  • zxc110110
  • 2012年01月07日 23:39
  • 583

(高效率排序算法一)并归排序

归并排序       归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。将已有序的子序列合并,得到完全有序的序列;即先...
  • h348592532
  • h348592532
  • 2015年04月30日 16:24
  • 1877

dfs 递归思想 解决排列组合的一些基础问题

对于搜索的深度很深或深度不固定的情况,则无法用枚举的方法来设置循环嵌套的层数,这时可以考虑用递归法来完成搜索任务。递归是一种常用算法,它是搜索的另一种实现方式。如果在算法设计中采用一个函数或过程直接或...
  • liuyanfeier
  • liuyanfeier
  • 2015年08月12日 20:31
  • 449

最有效率的方式遍历Map

package com.cn.filter; import java.util.HashMap; import java.util.Iterator; import java.util.Map;...
  • u012303775
  • u012303775
  • 2017年04月24日 09:21
  • 328

java标准高效的冒泡排序

public class BSort { public static void UseSort() { System.out.println("请输入数字:"); ...
  • u013719012
  • u013719012
  • 2016年10月30日 10:24
  • 83

最快排序和搜索算法的最简代码实现

                                      最快排序和搜索算法的最简代码实现                                              ...
  • shendl
  • shendl
  • 2009年04月07日 12:38
  • 27241

求幂的高效率算法

求幂的高效率算法,超小的时空复杂度,拒绝使用Math.pow()
  • qq_15771061
  • qq_15771061
  • 2016年07月05日 15:20
  • 322

硬币面值组合的算法题解

方法一 转自http://www.cnblogs.com/python27/archive/2013/09/05/3303721.html 动态规划的方法,是将m*n(m表示硬币的种类,n表示所要组...
  • styyzxjq2009
  • styyzxjq2009
  • 2014年07月16日 16:59
  • 3814
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:1-2-5组合问题的最高效完整算法
举报原因:
原因补充:

(最多只允许输入30个字)