LeetCode Weekly Contest 143

1103. Distribute Candies to People

We distribute some number of candies, to a row of n = num_people people in the following way:

We then give 1 candy to the first person, 2 candies to the second person, and so on until we give n candies to the last person.

Then, we go back to the start of the row, giving n + 1 candies to the first person, n + 2 candies to the second person, and so on until we give 2 * n candies to the last person.

This process repeats (with us giving one more candy each time, and moving to the start of the row after we reach the end) until we run out of candies. The last person will receive all of our remaining candies (not necessarily one more than the previous gift).

Return an array (of length num_people and sum candies) that represents the final distribution of candies.

Example 1:

Input: candies = 7, num_people = 4
Output: [1,2,3,1]
Explanation:
On the first turn, ans[0] += 1, and the array is [1,0,0,0].
On the second turn, ans[1] += 2, and the array is [1,2,0,0].
On the third turn, ans[2] += 3, and the array is [1,2,3,0].
On the fourth turn, ans[3] += 1 (because there is only one candy left), and the final array is [1,2,3,1].

Example 2:

Input: candies = 10, num_people = 3
Output: [5,2,3]
Explanation: 
On the first turn, ans[0] += 1, and the array is [1,0,0].
On the second turn, ans[1] += 2, and the array is [1,2,0].
On the third turn, ans[2] += 3, and the array is [1,2,3].
On the fourth turn, ans[0] += 4, and the final array is [5,2,3].

Constraints:

1 <= candies <= 10^9
1 <= num_people <= 1000

Title effect: to n individual sub candies, from 0 to n-1 sent sequentially, if left on the finished hair recycled.

Ideas: violence simulation.

class Solution {

    public int[] distributeCandies(int candies, int num_people) {
        int[] res = new int[num_people];
        int x = 1, ind = 0;
        while( candies >= x ) {
            res[ind] += x;
            candies -= x;
            x ++;
            ind = (ind+1)%num_people;
        }
        if( candies>=0 ) res[ind] += candies;
        return res;
    }
}

View Code

1104. Path In Zigzag Labelled Binary Tree

In an infinite binary tree where every node has two children, the nodes are labelled in row order.

In the odd numbered rows (ie., the first, third, fifth,...), the labelling is left to right, while in the even numbered rows (second, fourth, sixth,...), the labelling is right to left.

Given the label of a node in this tree, return the labels in the path from the root of the tree to the node with that label.

Example 1:

Input: label = 14
Output: [1,3,4,14]

Example 2:

Input: label = 26
Output: [1,2,6,10,26]

Constraints:

1 <= label <= 10^6

Title effect: to give you a tree node n, to find the path from the root node n 1. But the nodes of the tree are followed by "s" shaped marked by a progressive. That is:

In the odd-numbered lines (i.e., the first row, the third row, the fifth row ......), the labeled from left to right;

The even rows (i.e., the second row, the fourth row, the sixth row ......) in the order from right to left is labeled.

Ideas: Although node arrangement has changed, but the number of layers in which it is unchanged, according to the number of layers, down recursive, when the number of layers is odd, when the left and right sub-tree upside down like

class Solution {
    private int getLevel(int n) {
        int cnt = 0;
        int level = 0;
        for(level=0; ; level++) {
            cnt += Math.pow(2, level);
            if( cnt >= n ) return level;
        }
    }
    
    public List<Integer> pathInZigZagTree(int label) {
        List<Integer> list = new ArrayList<>();
        int level = getLevel(label);
        int cnt = 0;
        while( label > 0 ) {
            int res = label;
            if( cnt%2==1 && res != 1 ) {
                int low = (int) Math.pow(2, level);
                int high = (int) Math.pow(2, level+1)-1;
                res = low+high-res;
            }
            list.add(res);
            label /= 2;
            cnt ++;
            level --;
        }
        Collections.reverse(list);
        return list;
    }
}

View Code