组合商品问题

问题描述：http://blog.csdn.net/weixin_33226456/article/details/79506439

测试 test1.txt

3,3
2,3,1
bom1,2,1,1
bom2,1,1,0
bom3,0,1,1

代码框架 bom-frame.js（帮你做掉输入输出）

// read from stdin
process.stdin.setEncoding('utf8')
let input = ''
process.stdin.on('readable', () => {
  const chunk = process.stdin.read()
  if (chunk !== null) {
    input += chunk
  }
})
process.stdin.on('end', () => {
  const param = parseParam(input)
  const answer = solve(param.items, param.boms)
  console.log('match result:\n' + formatAnswer(answer, param.names))
})

// format answer
function formatAnswer(c_answer, c_names) {
  return c_answer
    .map((value, i)=>({idx:i,val:value}))
    .filter(x=>x.val>0)
    .map(x=>c_names[x.idx]+'*'+x.val)
    .join(',')
}

// parse input params
function parseParam(c_input) {
  const param = {}
  const lines = c_input.split('\n')
  const counts = lines[0].split(',')
  const nItem = Number(counts[0])
  const nBom = Number(counts[1])
  const boms = lines.slice(2, 2 + nBom).map(x=>x.split(','))
  param.nItem = nItem
  param.nBom = nBom
  param.items = lines[1].split(',').map(x=>Number(x))
  param.boms = boms.map(x=>x.slice(1).map(x=>Number(x)))
  param.names = boms.map(x=>x[0])
  return param
}

// ======== IGNORE CODES ABOVE FOR I/O ========
const maxNItem = 10
const maxNBom = 9
// ======== FOCUS ON SOLUTION BELOW ========
/* c_items: number of each item in order
 * c_boms: list of boms, each item is a list of
 */
function solve(c_items, c_boms) {
  return Array(c_boms.length).fill(0) // ### replace with your own code. 
}

 

完整解答 bom.js

// read from stdin
process.stdin.setEncoding('utf8')
let input = ''
process.stdin.on('readable', () => {
  const chunk = process.stdin.read()
  if (chunk !== null) {
    input += chunk
  }
})
process.stdin.on('end', () => {
  const param = parseParam(input)
  const answer = solve(param.items, param.boms)
  console.log('match result:\n' + formatAnswer(answer, param.names))
})

// format answer
function formatAnswer(c_answer, c_names) {
  return c_answer
    .map((value, i)=>({idx:i,val:value}))
    .filter(x=>x.val>0)
    .map(x=>c_names[x.idx]+'*'+x.val)
    .join(',')
}

// parse input params
function parseParam(c_input) {
  const param = {}
  const lines = c_input.split('\n')
  const counts = lines[0].split(',')
  const nItem = Number(counts[0])
  const nBom = Number(counts[1])
  const boms = lines.slice(2, 2 + nBom).map(x=>x.split(','))
  param.nItem = nItem
  param.nBom = nBom
  param.items = lines[1].split(',').map(x=>Number(x))
  param.boms = boms.map(x=>x.slice(1).map(x=>Number(x)))
  param.names = boms.map(x=>x[0])
  return param
}

// ======== IGNORE CODES ABOVE FOR I/O ========
const maxNItem = 10
const maxNBom = 9
// ======== FOCUS ON SOLUTION BELOW ========
/* c_items: number of each item in order
 * c_boms: list of boms, each item is a list of
 * 
 * 1. Solution can be represented by *vec*(vector of boms used).
 *    *vec* is an vector in space N^*nBom*.
 * 2. a viable *vec* gives a sulution in which sum of any item
 *    in all boms is not greater than that given by *items*.
 * 3. There must be at least one solution with minimal rest item types
 *    on the edge of viable region. (But without some of these bom types may
 *    get result with less bom types (better solution for this problem))
 *    Edge means adding any bom to the *vec* will result in a nonviable *vec*.
 *    i.e. we can find the best solution in the set: number of each bom is 
 *    either 0 or the max number with other bom number fixed.
 *    (prove by yourself)
 * 4. Traversal near the edge can find the answer.
 * 5. Use sparse matrix to save space if you use DP.(I am not using DP here,
 *    but this is a suggestion for your implementation)
 * 6. This is not the fastest algorithm for this problem since there are still
 *    some ways to cut more branches while traversing for best solution.
 */
function solve(c_items, c_boms) {
  // init to origin
  const vec = Array(c_boms.length).fill(0)
  const rest = c_items.slice()
  // lets first build a inverted index for finding related boms later
  const rel = c_boms.reduce((sum, cur, idx)=>cur.reduce((s,c,i)=>{
    if (c > 0) {
      if (s[i] != undefined) {
        s[i].push(idx)
      } else {
        s[i] = [idx]
      }
    }
    return s
  },sum),{})
  // recursive part
  const best = solveR(vec, 0, null, rest, c_boms, rel)
  return best.vec
}

/* recursive part:
 * With first *fixed* bom numbers fixed, find best vec
 */
function solveR(c_vec, c_fixed, c_best, c_rest, c_boms, c_rel) {
  // case 0: end of recursion
  let vec = c_vec.slice()
  if (c_fixed == c_boms.length) {
    let rest = c_rest.slice()
    removeHelplessBom(vec, rest, c_boms)
    const scr = score(vec, rest)
    if (c_best == null || scr < c_best.score) {
      return {score: scr, vec: vec}
    } else {
      return c_best
    }
  }
  // case 1: not all bom numbers fixed
  let distToEdge = c_boms[c_fixed].reduce((s, x, i) => {
    if (x == 0) {
      return s
    }
    let distI = Math.floor(c_rest[i] / x)
    return s == null ? distI : s <= distI ? s : distI
  }, null)
  vec[c_fixed] += distToEdge;
  let rest = calRest(c_rest, c_fixed, distToEdge, c_boms)
  let best = solveR(vec, c_fixed + 1, c_best, rest,  c_boms, c_rel)
  // check if we need to test cases with less *c_fixed*th bom
  let tryReduce = c_boms[c_fixed].some(
    (x, i) => x > 0 && c_rel[i].filter(x => x > c_fixed).length > 0
  )
  while(vec[c_fixed] > 0) {
    vec[c_fixed] --
    rest = calRest(rest, c_fixed, -1, c_boms)
    best = solveR(vec, c_fixed + 1, best, rest, c_boms, c_rel)
  }
  return best
}

// update rest value when *i*th com increase n
function calRest(c_rest, c_i, c_n, c_boms) {
  const newRest = c_rest.slice()
  return c_boms[c_i].reduce((sum,cur,idx)=>{sum[idx]-=cur*c_n;return sum}, newRest)
}

/* Let's call the boms which none of their related item types
 * is completely covered by boms "helpless" (helpless for better score).
 */
function removeHelplessBom(vec, v_rest, c_boms) {
  let rest = v_rest.slice();
  vec.forEach((veci, i) => {
    if (veci > 0) {
      let helpful = c_boms[i].some((val, idx) => val > 0 && rest[idx] == 0)
      if (!helpful) {
        vec[i] = 0
        rest = calRest(rest, i, -1 * veci, c_boms)
      }
    }
  })
  v_rest.length = 0
  v_rest.push(...rest)
}

// score a solution, the lower the better
function score(c_vec, c_rest) {
  const nUsedBomType = c_vec.filter(x=>x>0).length
  const nRestType = c_rest.filter(x=>x>0).length
  return nRestType * (maxNBom + 1) + nUsedBomType
}