算法设计与分析--分治

众数问题

给定含有n个元素的多重集合S，每个元素在S中出现的次数称为该元素的重数。多重集S中重数最大的元素称为众数。例如，S={1，2，2，2，3，5}。多重集S的众数是2，其重数为3。对于给定的由n 个自然数组成的多重集S，计算S的众数及其重数。如果出现多个众数，请输出最小的那个。

Input

输入数据的第1行是多重集S中元素个数n（n<1300000）；接下来的n行中，每行有一个最多含有5位数字的自然数，。

Output

输出数据的第1行给出众数，第2行是重数。

Sample Input

6
1
2
2
2
3
5

Sample Output

2
3

#include <bits/stdc++.h>
#include <string>
#include <iostream>

using namespace std;

void quickSort(int a[], int left, int right);
void findMax(int a[], int n);
int a[1300001];

int main()
{
   int n;
   cin>>n;
   for(int i = 0; i < n; i++)
   {
       cin>>a[i];
   }
   quickSort(a, 0, n - 1);
   findMax(a, n);
}

void quickSort(int a[], int left, int right)
{
    int i = left;
    int j = right;
    int temp = a[left];
    if(left >= right)
    {
        return;
    }
    while(i != j)
    {
        while(i < j&& a[j] >= temp)
        {
            j--;
        }
        if(j > i)
        a[i] = a[j];
        while(i < j && a[i] <= temp)
        {
            i++;
        }
        if(i < j)
        a[j] = a[i];
    }
    a[i] = temp;
    quickSort(a, left, i - 1);
    quickSort(a, i + 1, right);
}

void findMax(int a[], int n)
{
    int i = 0;
    int Max = -1, maxNum = 0;   // 最大的数   出现的次数
    while(i < n - 1){
        int j = i + 1;
        int count = 1;
        int temp = a[i];
        while(a[i] == a[j]){
            temp = a[j];
            count++;
            i++;
            j++;
        }
        if(count > maxNum){
            maxNum = count;
            Max = temp;
        }
        i++;
    }
    printf("%d\n%d\n", Max, maxNum);
}

 

骨牌铺方格

在2×n的一个长方形方格中,用一个1× 2的骨牌铺满方格,输入n ,输出铺放方案的总数. 例如n=3时,为2× 3方格，骨牌的铺放方案有三种,如下图： 

Input

输入数据由多行组成，每行包含一个整数n,表示该测试实例的长方形方格的规格是2×n (0< n<=50)。

Output

对于每个测试实例，请输出铺放方案的总数，每个实例的输出占一行。

Sample Input

1
3
2

Sample Output

1
3
2

递推解决，找规律

#include <bits/stdc++.h>
#include <iostream>

using namespace std;

int main()
{
    int n;
    long long int a[1000];
    while(cin>>n){
        a[0] = 0;
        a[1] = 1;
        a[2] = 2;
        for(int i = 3; i <= n; i++){
            a[i] = a[i - 1] + a[i - 2];
        }
        cout<<a[n]<<"\n";  // 如果使用printf，那么这个地方是%lld, 因为定义的是long long 类型
    }
    return 0;
}

 

 

顺序表应用7：最大子段和之分治递归法

Time Limit: 10 ms Memory Limit: 400 KiB

 给定n(1<=n<=50000)个整数（可能为负数）组成的序列a[1],a[2],a[3],…,a[n],求该序列如a[i]+a[i+1]+…+a[j]的子段和的最大值。当所给的整数均为负数时定义子段和为0，依此定义，所求的最优值为： Max{0,a[i]+a[i+1]+…+a[j]},1<=i<=j<=n。 例如，当（a[1],a[2],a[3],a[4],a[5],a[6]）=(-2,11,-4,13,-5,-2)时，最大子段和为20。

 

注意：本题目要求用分治递归法求解，除了需要输出最大子段和的值之外，还需要输出求得该结果所需的递归调用总次数。

 

递归调用总次数的获得，可以参考以下求菲波那切数列的代码段中全局变量count的用法：

#include
int count=0;
int main()
{
    int n,m;
    int fib(int n);
    scanf("%d",&n);
    m=fib(n);
    printf("%d %d\n",m,count);
    return 0;
}
int fib(int n)
{
    int s;
    count++;
    if((n==1)||(n==0)) return 1;
    else s=fib(n-1)+fib(n-2);
    return s;
}
 

Input

第一行输入整数n(1<=n<=50000)，表示整数序列中的数据元素个数；

第二行依次输入n个整数，对应顺序表中存放的每个数据元素值。

Output

一行输出两个整数，之间以空格间隔输出：

第一个整数为所求的最大子段和；

第二个整数为用分治递归法求解最大子段和时，递归函数被调用的总次数。

Sample Input

6
-2 11 -4 13 -5 -2

Sample Output

20 11

#include <bits/stdc++.h>
#include <iostream>

using namespace std;
int a[50010], cnt;

int findMax(int l, int r)
{
    cnt++; // 关于次数，进入函数就需要对次数+1
    int sum = 0;
    if(l == r){
        if(a[l] >= 0) sum = a[l];
        else  sum = 0;
    }
    else{
        int s1 = 0, s2 = 0, ss = 0;   // 中间交合部分的和， 其中的参数都是l 或者 r
        int mid = (l + r) / 2;
        for(int i = mid; i >= l; i--){
            ss += a[i];
            s1 = max(ss, s1);
        }
        ss = 0;
        for(int j = mid + 1; j <= r; j++){
            ss += a[j];
            s2 = max(ss, s2);
        }
        sum = s1 + s2;
        int suml = findMax(l, mid);  // 左侧的最大值
        int sumr = findMax(mid + 1, r);  // 右侧的最大值
        sum = max(sum, suml);
        sum = max(sum, sumr);
    }
    return sum;
}

int main()
{
    int n;
    scanf("%d", &n);
    for(int i = 0; i < n; i++){
        scanf("%d",&a[i]);
    }
    cnt=0;
    int maxH = findMax(0, n - 1);
    printf("%d %d\n", maxH, cnt);
    return 0;
}

采坑：在输出时，用cout会超时

Time Limit Exceeded

  scanf是格式化输入，printf是格式化输出。cin是输入流，cout是输出流。效率稍低，但书写简便。格式化输出效率比较高，但是写代码麻烦。流输出操作效率稍低，但书写简便。cout之所以效率低，是先把要输出的东西存入缓冲区，再输出，导致效率降低。缓冲区比较抽象，举个例子吧：

int i;

cout<<'a';

cin>>i;

cout<<'b';

运行结果什么都没看到输出，输入一个整型比如3再按回车后ab同时显示出来了。

但是这样的情况并不是经常发生，是在一些比较大型的工程中偶尔出现，原因是字符a先到了缓冲区，但是没输出，等输入了i，b进入缓冲区后再一并输出的。流输入也是差不多的。使用scanf应该不会有time limit 的风险。
 

整数因子分解问题

Time Limit: 1000 ms Memory Limit: 65536 KiB

Problem Description

大于1的正整数n可以分解为：n=x1*x2*…*xm。例如，当n=12 时，共有8 种不同的分解式： 
12=12； 
12=6*2； 
12=4*3； 
12=3*4； 
12=3*2*2； 
12=2*6； 
12=2*3*2； 
12=2*2*3。
对于给定的正整数n，计算n共有多少种不同的分解式。

Input

输入数据只有一行，有1个正整数n (1≤n≤2000000000)。

Output

将计算出的不同的分解式数输出。

Sample Input

12

Sample Output

8

Hint

普通递归，栈会溢出

#include <bits/stdc++.h>

using namespace std;

int a[10005], k;   // 数组a保存因子，k为a数组最后一位因子的下一位值所在位置
int h[10005];      // 保存最终的因子数

void disvisor(int n)
{
    int i;  // i在外面进行定义
    for(i = 1; i < sqrt(n); i++) // 对于循环，由于没了本身，所以从1开始
    {
        if(n % i == 0){
            a[k++] = i;  // 首先i先存到因子数组中
            a[k++] = n / i;  // n/i可以整除的开，所以n/i也是因子
        }
    }
    if(i * i == n){  // 处理因子相同的情况，出现在sqrt(n)处
        a[k++] = i;
    }
}

int solve()
{
    h[0] = 1; // 新开启记录的数组
    for(int i = 1; i < k; i++)
    {
        for(int j = 0; j < i; j++)
        {
            if(a[i] % a[j] == 0)
            {
                h[i] += h[j];
            }
        }
    }
    return h[k - 1];  // 注意返回的坐标
}

 int main()
 {
     int n;
     k = 0;
     scanf("%d", &n);
     disvisor(n);
     sort(a, a+k); // 注意sort的使用，第一个是要排序的数组的起始地址，第二个是结束的地址（最后一位要排序的地址）时间复杂度为n*log2(n)
     printf("%d\n", solve());
     return 0;
 }

 

这是网上其他人的答案，没咋看懂，

#include <bits/stdc++.h>
 using namespace std;

map<int, int> a;

 int Fenjie(int n)
 {
     if(n == 1)
        return 1;
     if(a[n])
        return a[n];
     int cnt = 1;

     for(int i = 2; i <= sqrt(n); i++)
     {
         if(n % i == 0)
         {
             cnt += Fenjie(i);
             if(i != n / i)
             {
                 cnt += Fenjie(n / i);
             }
         }
     }
     a[n] = cnt;
     return cnt;
 }

 int main()
 {
     int n;
     scanf("%d", &n);
     int m = Fenjie(n);
     printf("%d\n", m);
     return 0;
 }