東京大学 新領域創成科学研究科 メディカル情報生命専攻 2019年8月実施 問題7

Author

zephyr

Description

Let be an array of size , whose elements are different integers ranging from to . Let be the number of all possible distinct arrays each of which can be created by iteratively applying the following operation to , or more times.

Operation: choose arbitrary that satisfies and , and swap the values of and .

We denote the largest number in array by , and the smallest number by .

(1) Let . Show for , respectively.

(2) When , prove . Here, denotes an array that is array with element removed.

(3) When , prove . Here, we define .

(4) Show an algorithm that computes from using (2) and (3).

(5) Let . We define as the worst time complexity of the algorithm you showed in (4). Write in terms of , and prove it. You can assume that addition, comparison, copy of two elements take unit time.

(6) Let . Assuming that the possible permutations have equal probability of being generated as the input array, write the average time complexity of the algorithm you showed in (4).

---

设 为一个大小为 的数组，其元素为 到 范围内的不同整数。设 为可以通过对 进行 次或多次以下操作创建的所有可能不同数组的数量。

操作：选择满足 且 的任意 ，交换 和 的值。

我们将数组 中的最大数记为 ，最小数记为 。

(1) 设 。分别显示 时的 。

(2) 当 时，证明 。这里， 表示从数组 中移除元素 后的数组。

(3) 当 时，证明 。这里，我们定义 。

(4) 使用 (2) 和 (3) 展示一个从 计算 的算法。

(5) 设 。我们定义 为你在 (4) 中展示的算法的最坏时间复杂度。用 表示 ，并证明它。你可以假设两个元素的加法、比较、复制操作的时间为一个单位时间。

(6) 设 。假设 个可能的排列作为输入数组被生成的概率相等，写出你在 (4) 中展示的算法的平均时间复杂度。

Kai

(1)

Given :

For

To find for , we need to consider the operation condition . We start with the initial array and systematically apply all valid swaps.

Initial array:

We need to check all possible adjacent swaps under the condition :

Swap and (since ):

Swap and back (since ):

Swap and (since ):

Swap and (since ):

All valid permutations for are:

Therefore, for :

For

For , we need to explore more possible swaps as the condition is more lenient.

Initial array:

We start with the initial array and apply all valid swaps:

Swap and (since ):

Swap and (since ):

Swap and (since )

Now explore permutations of :

Swap and (since ):

Now explore permutations of :

Swap and (since ):

Swap and (since ):

Now explore permutations of :

Swap and (since ):

Now explore permutations of :

Similarly, we get:

Thus, the valid permutations for are:

Therefore, for :

(2)

When , prove .

Given , the smallest number can be swapped with any adjacent element and can move to any position in the array.

Therefore, the number of permutations of is equal to the number of permutations of , multiplied by the number of possible positions for , which is . Hence, we have:

(3)

When , prove .

If , then and , or and any other element of the array, cannot be swapped, effectively dividing into two independent subarrays. Thus, the total number of distinct arrays is the product of the number of distinct arrays of each subarray:

(4)

Algorithm to compute :

def compute_S(A, W):
    if len(A) == 0:
        return 1
	
	# O(N)
    a_h = max(A)
    a_l = min(A)
    
    if a_h + a_l < W:
	    # O(N)
        A_minus_a_l = [x for x in A if x != a_l]
        return len(A) * compute_S(A_minus_a_l, W)
        # T(N-1)
    else:
        index_h = A.index(a_h)
        left_part = A[:index_h]
        right_part = A[index_h+1:]
        return compute_S(left_part, W) * compute_S(right_part, W)
		# 2*T(N/2)

# Example
A = [4, 1, 10, 3, 2]
W = 11
print(compute_S(A, W))  # Output: 4
W = 12
print(compute_S(A, W))  # Output: 10

(5)

Given that the worst-case scenario involves removing the smallest element each time, the time complexity can be analyzed as follows:

1. Initial size:
2. Operation: Finding the smallest element (which takes time) and removing it, reducing the problem size by 1.
3. Recurrence relation: The total time complexity is the sum of the times taken for each step as we reduce the size of the array from to 0.

The time complexity can be expressed as:

This is the sum of the first natural numbers:

Therefore, the worst-case time complexity is:

(6)

Assuming that each of the permutations of the array is equally likely, and given that the average scenario does not always involve removing the smallest element each time, the time complexity will be different.

In the average case, the algorithm will involve both scenarios of removing the smallest element and splitting the array. However, the average number of operations will not always hit the worst-case scenario.

Considering the balanced approach where the split operation happens frequently, the recurrence relation can be described more favorably compared to the worst-case:

Using the Master Theorem for , , and :

Thus, the average time complexity is:

Knowledge

组合计数 递归 复杂度分析 主定理

解题技巧和信息

1. Recursive Reduction: Understand how reducing a problem by removing an element or splitting the array affects complexity.
2. Complexity Analysis: Sum of first numbers is .
3. Master Theorem: Useful for solving recurrence relations in divide-and-conquer algorithms.

重点词汇

• worst-case 最坏情况
• average-case 平均情况
• time complexity 时间复杂度
• recurrence relation 递推关系

参考资料

1. Introduction to Algorithms by Cormen, Leiserson, Rivest, and Stein, Chapter 4.