Wood Cut

Given n pieces of wood with length L[i] (integer array). Cut them into small pieces to guarantee you could have equal or more than k pieces with the same length. What is the longest length you can get from the n pieces of wood? Given L & k, return the maximum length of the small pieces.

 Notice

You couldn't cut wood into float length.

Example

For L=[232, 124, 456], k=7, return 114.

Analyse:

Runtime: Time exceeded. 

class Solution {
public:
    /** 
     *@param L: Given n pieces of wood with length L[i]
     *@param k: An integer
     *return: The maximum length of the small pieces.
     */
    int woodCut(vector<int> L, int k) {
        // write your code here
        if (L.empty()) return 0;
        // first sort the array
        sort(L.begin(), L.end());
        // fix the first number x, calculate the times of other numbers to x and sum them to check if exceed k.
        // If exceeded, use binary divide to narrow the value of x
        // If not exceeded, save and update result.
        int result = 0;
        for (int i = 0; i < L.size(); i++) {
            // first check if L[i] is the longest length
            // say if the sum of times of each number <= k, then we need to more devide L[i]; otherwise, let it continue
            int tempCount = 0;
            for (int j = 0; j < L.size(); j++)
                tempCount += L[j] / L[i];
            if (tempCount >= k) {
                result = max(result, L[i]);
                continue;
            }
            else {
                int low = 1, high = L[i];
                while (low <= high) {
                    int tempPieces = 0, mid = low + (high - low) / 2;
                    for (int j = 0; j < L.size(); j++)
                        tempPieces += L[j] / mid;
                    if (tempPieces >= k) {
                        result = max(result, mid);
                        low = mid + 1;
                    }
                    else high = mid - 1;
                }
                result = max(result, high);
                return result;
            }
        }
        return result;
    }
};

Analyse: Find the longest wood and use binary search to find a right one. 

class Solution {
public:
    /** 
     *@param L: Given n pieces of wood with length L[i]
     *@param k: An integer
     *return: The maximum length of the small pieces.
     */
    int woodCut(vector<int> L, int k) {
        // write your code here
        if (L.empty()) return 0;
        
        // find max, use binary search to scan possible values between 1 and max
        sort(L.begin(), L.end());
        int low = 1, high = L[L.size() - 1], result = 0;
        while (low <= high) {
            int mid = low + (high - low) / 2, tempPieces = 0;
            for (int number : L) 
                tempPieces += number / mid;
            if (tempPieces >= k) {
                result = max(result, mid);
                low = mid + 1;
            }
            else high = mid - 1;
        }
        return result;
    }
};