[lintcode] 1442.订单问题 [Medium]

描述

现在有一个订单，对n 种商品有需求，对第 i 种商品的需求为 order[i] 个。工厂有 m 种生产模式，每种生产模式形如 [p[1],p[2],...p[n]]，即同时生产第 1 种商品 p[1] 个，第 2 种商品 p[2] 个……你可以使用多种生产模式，请问在不超过任意一种商品的需求的情况下，未满足需求的商品最少有多少个?

 

样例

给出 order=[2,3,1]，pattern=[[2,2,0],[0,1,1],[1,1,0]]，返回 0

解释：
使用 [0,1,1] 一次，[1,1,0] 两次，剩余 [0,0,0]。

给出 order=[2,3,1]，pattern=[[2,2,0]]，返回 2。

解释：
使用 [2,2,0] 一次，剩余 [0,1,1]。

思路 

这道题有一个明显的暗示是 0<= n,m <= 7，然后所有的产品数目小于10。 也就暗示了要用枚举（dfs）的方法去做。

因为过了我也就没管，但是感觉可以把[2,3,1]这样的order hash到一种状态，可以剪一部分的枝.

*注意一点是如果出现全0的pattern会导致死循环，要单独考虑

 

class Solution {
public:
    /**
     * @param order: The order
     * @param pattern: The pattern
     * @return: Return the number of items do not meet the demand at least
     */
     
    int cntNeqZero(vector<int> order, int n)
    {
        int cnt=0;
        for(int i=0; i<n; ++i)
        {
            cnt += order[i];
        }
        
        return cnt;
    }
    
    bool allZero(vector<int> pattern, int n)
    {
        for(int i=0; i<n; ++i)
        {
            if(pattern[i] != 0)
            {
                return false;
            }
        }
        
        return true;
    }
    
    
    
    int dfs(vector<vector<int>> pattern, vector<int> order, int n)
    {
        int min = cntNeqZero(order,n);
    
        for(auto i:pattern)
        {
            if(allZero(i, n))
            {
                continue;
            }
            
            vector<int> tmp;
            int tmpVal = 0;
            
            for(int j=0; j<n; ++j)
            {
                tmpVal = order[j] - i[j];
                if(tmpVal < 0)
                {
                    break;
                }
                else
                {
                    tmp.emplace_back(tmpVal);
                }
            }
            
            
            if(tmpVal < 0)
            {
                tmp.clear();
                continue;
            }
            
            int retMin = dfs(pattern, tmp, n);
            if(retMin < min)
            {
                min = retMin;
                if(min == 0)
                {
                    return 0;
                }
            }
            
        }
        return min;
    }

    
    int getMinRemaining(vector<int> &order, vector<vector<int>> &pattern) {

        int min=order.size();
        int n = order.size();
        
        
        return dfs(pattern, order, n);
    
        
    }
};