Algorithm homework 1

一、已知下列递推式：

\[C(n)=
\begin{cases}
1 & , & n = 1 \\
2C(n/2) + n - 1& , & n \geq 2
\end{cases}
\]

请由定理1 导出C(n)的非递归表达式并指出其渐进复杂性.

定理1：设$a,c$为非负整数，$b,d,x$为非负常数，并对于某个非负整数$k$, 令$n=c^k$, 则以下递推式

\[f(n)=
\begin{cases}
d & , & n=1 \\
af(n/c)+bn^x& , & n\geq2
\end{cases}
\]

的解是

\[f(n)=
\begin{cases}
bn^xlog_cn + dn^x & , & n=1 \\
\left( d + \frac{bc^x}{a-c^x} \right)n^{log_ca} - \left( \frac{bc^x}{a-c^x}\right)n^x& , & n\geq2
\end{cases}
\]

令 $T(n) = C(n) - 1$，则

\[T(n)=
\begin{cases}
0 & , & n = 1 \\
2T(n/2) + n & , & n \geq 2
\end{cases}
\]

则$T(n)$满足定理1中递推式，且$a = 2, b = 1, c = 2, d = 0, x = 1$, 即有$2 = 2^1$

故当$n = 2^k$时，$T(n)$的解为

\[T(n) = nlog_2n
\]

则$C(n)$的非递归表达式为

\[C(n) = T(n) + 1 = nlog_2n + 1
\]

所以其渐进复杂性为$\Theta(nlog_2n)$

二、由于Prim算法和Kruskal 算法设计思路的不同，导致了其对不同问题实例的效率对比关系的不同。请简要论述：

1、如何将两种算法集成，以适应问题的不同实例输入；

Prim算法基于每个点, 要遍历所有的点。

Kruskal算法基于边, 要遍历许多边。

因此可以在边比较稀疏的情况下用Kruskal算法,在边较稠密的情况下使用Prim算法.

2、你如何评价这一集成的意义？

通常实现下Prim是$O(V^2)$的时间复杂度，但可以使用优先队列将时间复杂度优化到$O(Elog_2V)$，而Kruskal使用排序+并查集实现的复杂度为$O(Elog_2E)$,两者最优时间复杂度差别仅为log级别的，且Prim平均情况下效果会更好。因此这一集成大概只是增加了代码复杂度，仅用Prim算法的效果可能会更好。

三、分析以下生成排列算法的正确性和时间效率：

HeapPermute(n)

    //实现生成排列的Heap算法

    //输入：一个正整数n和一个全局数组A[1..n]

    //输出：A中元素的全排列

    if n = 1

        write A

    else

        for i ← 1 to n do

            HeapPermute(n-1)

            if n is odd

                swap A[1] and A[n]

            else swap A[i] and A[n]

1. 正确性

设 k 为正整数且 $ k \leq n$,记$A[1..n]$为$A=[a_1, a_2, \cdots, a_n]$

我们有以下结论：在执行算法$HeapPermute(k)$后, 输出 A 前 k 位的全排列，后$n − k$位不变。(特别地, 当 k = n 时, 输出的就是 A 的全排列。) 执行算法$HeapPermute(k)$前后, 当 k 为奇数时, A 保持不变；当n为偶数时, A 的前 k 位循环右移一位。

下面数学归纳法证明该结论：

证明：

(1) 当$k = 1$时，算法$HeapPermute(k)$输出$[a_1, a_2, \cdots, a_n]$，与结论相符。
(2) 假设当$k = 2j - 1(j $为正整数$)$，且$k < n $时，执行$HeapPermute(k)$输出 A 前 k 位的全排列，后$n − k$位不变，且A保持不变。则当$k = 2j$时，对于$i = 1, 2, \cdots, 2j$时，分别输出A的前$2j-1$位的全排列,A的后$(n - 2j + 1)$位不变，程序向下执行到第10行，由于n为偶数，则$swap(a_i,a_{2j})$。之前所有操作仅改变A数组的前$2j$位，然后输出$2j - 1$位，后后$(n - 2j + 1)$位不变。最后依次将A的第$1, 2, \cdots, 2j$位交换到第2m位。因此上述操作得到了A的前2j位的全排列且前2j位循环右移一位，后$n-2j$位不变。与结论相符。
(3) 假设当$k = 2j(j $为正整数$)$，且$k < n$时，，执行$HeapPermute(k)$输出 A 前 k 位的全排列，后$n − k$位不变，且 A 的前 k 位循环右移一位。类似的可得到当$k=2j+1$时, A 保持不变。

因此结论得证，执行算法HeapPermute(n)可以输出全局数组$A = [1..n]$的全排列。

2. 时间效率

考虑交换操作的耗时，有递推公式如下：

\[T(n)=
\begin{cases}
1 & , & n = 1 \\
n\left[T(n - 1) + 1\right] & , & n \geq 2
\end{cases}
\]

化简得$T(n) = n! + O(n^{n-1})$

故$T(n)$的时间复杂度为$O(n!) + O(n^{n-1})$

四、对于求n 个实数构成的数组中最小元素的位置问题，写出你设计的具有减治思想算法的伪代码，确定其时间效率，并与该问题的蛮力算法相比较。

FindMin(n)

    //实现寻找数组中最小元素的位置

    //输入：一个正正整数n和一个全局数组A[1..n]

    //输出：A中最小元素m及其位置a

    if n == 1：

        return A[1], 1

    else

        m, a = FindMin(n-1)

    if m <= A[n]:

        return m, a

    else

        return A[n], n

上述减治方法每次将问题的规模约减1，因此时间复杂度为$O(n)$,与该问题的蛮力算法时间复杂度相同。

五、请给出约瑟夫斯问题的非递推公式 J（n），并证明之。其中，n 为最初总人数，J(n) 为最后幸存者的最初编号。

约瑟夫问题的非递推公式为：

\[J(n) = 1 + 2(n - 2^{\lfloor log_2n \rfloor}), \ n = 1, 2, 3, \cdots
\]

令$m = {\lfloor log_2n \rfloor}$，$l = n - 2^m，$则$J(n) = 2l+1$

首先我们很容易知道该问题的通项公式为

\[\begin{array}{l}
J(2n) = 2J(n) - 1 & , & n 为偶数 \\
J(2n + 1) = 2J(n) + 1 & ,& n为奇数
\end{array}
\]

下用归纳法证明该通项。

证明

当$n = 1$时，上式显然成立。
假设$n$是偶数，取$m_1、l_1$使得$n/2=2^{m_{1}}+l_{1}$，且$0\leq l_{1}<2^{{m_{1}}}$。这里$l_{1}=l/2$。我们有$f(n)=2f(n/2)-1=2((2l_{1})+1)-1=2l+1$，其中第二个等式从归纳假设推出。
假设$n$是奇数，则我们选择$l_{1}$和$m_{1}$，使得$(n-1)/2=2^{{m_{1}}}+l_{1}$，且$0\leq l_{1}<2^{{m_{1}}}$。注意$l_{1}=(l-1)/2$。我们有$f(n)=2f((n-1)/2)+1=2((2l_{1})+1)+1=2l+1$，其中第二个等式从归纳假设推出。证毕。

综上，对所有的自然数n，原结论成立。证毕。