FZU Problem 1919 K-way Merging sort(大数+记忆化搜索)

Posted ITAK

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了FZU Problem 1919 K-way Merging sort(大数+记忆化搜索)相关的知识,希望对你有一定的参考价值。

传送门

As we all known, merge sort is an O(nlogn) comparison-based sorting algorithm. The merge sort achieves its good runtime by a divide-and-conquer strategy, namely, that of halving the list being sorted: the front and back halves of the list are recursively sorted separately, then the two results are merged into the answer list. An implementation is shown as follows:

The procedure Merge(L1,L2:in List_type;L:out List_type) that we have in mind for sorting two lists is described as follows. Initialize pointers to the first item in each list L1,L2, and then

repeat

  compare the two items pointed at;

  move the smaller into L;

  move the pointer which originally points at the smaller one to the next number;

until one of L1,L2 exhausts;

drain the remainder of the unexhausted list into L;

Now let us come to the situation when there are k pointers, here k≥2. Let L be a list of n elements. Divide L into k disjoint contiguous sublists L1,L2,…,Lk of nearly equal length. Some Li’s (namely, n reminder k of them, so possibly none) will have length , let these have the low indices: L1,L2,…,Ln%k Other Li’s will have length , and high indices are assigned: Ln%k+1,…,Lk-1,Lk. We intend to recursively sort the Li’s and merge the k results into an answer list.

We use Linear-Search-Merge here to merge k sorted lists. We find the smallest of k items (one from each of the k sorted source lists), at a cost of k-1 comparisons. Move the smallest into the answer list and advances its corresponding pointer (the next smallest element) in the source list from which it came. Again there are k items, from among which the smallest is to be selected. (When i (1 ≤ i < k) lists are empty, k-way merging sort becomes to (k-i)-way merging sort, and the draining process will start when the total order of all the elements have been found)

Given a list containing n elements, your task is to find out the maximum number of comparisons in k-way merging sort.

Input

The first line of the input contains an integer T (T 100), indicating the number of cases. Each case begins with a line containing two integer n (1 ≤ n ≤ 10 100) and k (2 ≤ k ≤ 20), the number of elements in the list, and it is k-way merging sort.

Output

For each test case, print a line containing the test case number (beginning with 1) and the maximum number of comparisons in k-way merging sort.

Sample Input

4
2 2
3 2
100 7
1000 10

Sample Input

Case 1: 1
Case 2: 3
Case 3: 1085
Case 4: 22005


题目大意:
对于归并排序,本来是2-路分治,现在要求k-路分治,求n个元素下k-路分治归并排序所需要的最大比较次数?

解题思路:
对于 n 个元素k-路分治,将元素 1n 分为 k 段,前s=n%k段每段有 nk+1 个元素,后 ks 段每段有 nk 个元素,那么对这 k 段进行归并时和2-路一样,选出这 k 段中的最小值放入合并后的数组,每次从k段中选出一个最小值需要比较 k1 次,当每一段均剩下一个元素时,共选出了n-k个最小值,所以比较了 k1nk 次,对于剩下的 k 个元素则需要比较k1+k2++1=k1k2次,所以共需要 k1nk+k1k2 次,然后递归进一步分治,注意使用记忆化搜索,否则超时。

注意:本题数据很大所以不能用数组存值,而用的 map 映射的。

代码如下:

import java.math.BigInteger;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class Main
    static Map<BigInteger,BigInteger>dp = new HashMap<BigInteger,BigInteger>();
    static BigInteger n, ans;
    static int k;
    static BigInteger dfs(BigInteger len, BigInteger x)
        if(dp.containsKey(len)) return x.multiply(dp.get(len));
        if(len.compareTo(BigInteger.valueOf(k))<=0)
            return x.multiply(len.subtract(BigInteger.ONE)).multiply(len).divide(BigInteger.valueOf(2));
        
        BigInteger tmp = (BigInteger.valueOf(k).subtract(BigInteger.ONE)).multiply((len.subtract(BigInteger.valueOf(k))));
        tmp = tmp.add(BigInteger.valueOf(k).multiply(BigInteger.valueOf(k).subtract(BigInteger.ONE)).divide(BigInteger.valueOf(2)));
        BigInteger kk = len.mod(BigInteger.valueOf(k));
        if(kk!=BigInteger.ZERO)
            tmp=tmp.add(dfs(len.divide(BigInteger.valueOf(k)).add(BigInteger.ONE),kk));
        
        tmp = tmp.add(dfs(len.divide(BigInteger.valueOf(k)),BigInteger.valueOf(k).subtract(kk)));
        dp.put(len, tmp);
        return tmp.multiply(x);
    
    public static void main(String[] args) 
        Scanner in = new Scanner(System.in);
        int T = in.nextInt();
        for(int cas=1; cas<=T; cas++)
            dp.clear();
            n = in.nextBigInteger();
            k = in.nextInt();
            ans=dfs(n, BigInteger.ONE);
            System.out.println("Case "+cas+": "+ans);
        
    

以上是关于FZU Problem 1919 K-way Merging sort(大数+记忆化搜索)的主要内容,如果未能解决你的问题,请参考以下文章

FZU-2214 Knapsack problem

(01背包 当容量特别大的时候) Knapsack problem (fzu 2214)

FZU-2218 Simple String Problem

FZU Problem 1853 Number Deletion

FZU Problem 1692 Key problem(循环矩阵)

FZU - 2037 -Maximum Value Problem(规律题)