JS算法——算法的设计和技巧（尚未完善）

一些算法的设计

分而治之

分成三部分：

1. 分解原问题为多个子问题
2. 解决子问题，用返回解决子问题的方式的递归算法
3. 组合这些子问题的解决方法，得到原问题的解

归并和排序算法都是分而治之的算法

同样的二分搜索也可以采用该方法实现，详细的步骤为：

1. 分解：计算mid并搜索数组较小或者较大的一半
2. 解决：在较小或者较大的一半中搜索值
3. 合并：这里是直接返回值

function binarySearchRecursive(array,value,low,high){
    if(low<=high){
        const mid = Math.floor((low+high)/2)
        const element = array[mid]
        if(element<value){
            return binarySearchRecursive(array,value,mid+1,high)
        }else if(element>value){
            return binarySearch(array,value,low,mid-1)
        }else{
            return mid
        }
    }
    return -1
}

export function binarySearch(array,value){
    const sortedArray = quickSort(array)
    const low = 0
    const high = sortedArray.length-1
    return binarySearchRecursive(array,value,low,high)
    
}

动态规划

将复杂问题分解成更小的子问题开解决

使用动态规划需要注意三个步骤：

1. 定义子问题
2. 实现要反复执行来解决子问题的部分（类似递归
3. 识别并求解出基线条件

用动态规划解决的一些著名问题：

1. 背包问题：给出一组项，各自有值和容量，目标是找出总值最大的项的集合。限制在于总容量必须小于等于“背包”的容量

   他描述为：给一个固定大小，能够携重量W的背包，以及一组有价值和重量的物品，找到一个最佳解决方案，使得装入背包的物品总重量不超过W并且总价值 最大

//背包算法
function knapSack(capacity,weights,values,n){
    const KS = []
    for(let i = 0;i<=n;i++){
        KS[i] = []
    }
    for(let i = 0;i<=n;i++){
        forr(ley w = 0;w<=capacity;w++){
            if(i === 0 || w===0){
                KS[i][w] = 0
            }else if(weights[i-1]<=w){
                const a = values[i-1]+KS[i-1][w-weight[i-1]]
                const b = KS[i-1][w]
                KS[i][w] = a>b?a:b
            }else{
                KS[i][w] = KS[i-1][w]
            }
        }
    }
    findValues(n,capacity,KS,weights,values)
    return KS[n][capacity]
}

2. 最长公共子序列：找出一组序列的最长公共子序列（可由另一序列删除元素但不改变余下元素的顺序而得到的）

   找出两个字符串序列的最长子序列的长度。最长子序列是指，在两个字符串序列中以相同顺序出现，但不要求连续的字符串序列

   //最长公共子序列算法
   function lcs(wordX,wordY){
       const m = wordX.length
       const n = wordY.length
       const l = []
       for(let i = 0; i<=m ; i++){
           l[i] = []
           for(let j = 0; j<=n;j++){
               let[i][j] = 0
           }
       }
       for(let i = 0;i<=m;i++){
           for(let j = 0;j<=n;j++){
               if(i===0||j===0){
                   l[i][j] = 0
               }else if(wordX[i-1) === wordY[j-1]{
                   l[i][j] = l[i-1][j-1]+1
               }else{
                   const a = l[i-1][j]
                   const b = l[i][j-1]
                   l[i][j] = a>b?a:b
               }
           }
       }
       return l[m][n]
   }
   

3. 矩阵链相乘：给出一系列矩阵，目标是找到这些矩阵相乘的最高效办法（计算次数尽可能少）。相乘运算不会进行，解决方案是找到这些矩阵各自相乘的顺序

   这个问题是要找出矩阵相乘的最佳方式，m行n列的矩阵A和m行p列的矩阵B，结果是n行p列的矩阵C

   考虑到A* B * C * D的乘法，因此假设有以下几种情况：

   1. A是一个10行100列的矩阵
   2. B是一个100行5列的矩阵
   3. C是有一个5行50列的矩阵
   4. D是一个50行1列的矩阵

   A* B * C * D 的结果是一个10行1列的矩阵

   由于相乘的顺序不一样，结果也不一样，所以需要构建一个算法，求出最少的乘法运算次数

   function matrixChainOrder(p){
       const n = p.length
       const m =[]
       const s= []
       for(let i = 1;i<=n:i++){
           m[i] = []
           m[i][i] = 0
       }
       for(let l= 2;l<n;l++){
           for(let i = 1;i<=(n-1)+1;i++){
               const j = (i+1)-1
               m[i][j] = Number.MAX_SAFE_INTEGER
               for(let k = i;k<=j-1;k++){
                   const q = m[i][k]+m[k+1][j]+((p[i-1]*p[k]*p[j]))
                   if(q<m[i][j]){
                       m[i][j] = q
                   }
               }
           }
       }
       return m[l][n-1]
   }
   

4. 硬币找零：给出面额为d1—dn的一定数量的硬币和要找零的钱数，找出有多少种方法

   最少硬币找零，是其中一种变种，找出最少需要的硬币个数

   //例如美国有以下面额的硬币：
   //d1 = 1,d2 = 5,d3 = 10,d4 = 25
   //如果要找36美分的零钱，可以用一个25+一个10+一个1
   //需要找到n所需要的最小硬币数，首先需要找到每个x<n的解，然后可以基于更小的值的解求解
   
   function minCoinChange(coins,amout){
       //这里声明一个cache，用来接收coins参数，并且为了搞笑不重复计数
       const cache = {}
       //用一个递归解决问题，主要逻辑为若amount不为正，那么就返回空数组，在方法执行后会返回一个数组，包含用来找零的各个面额的硬币数量，接着检查cache缓存，若结果已经缓存则直接返回结果，如果没有的话，继续执行算法
       const makeChange = (value)=>{
           if(!value){
               return []
           }
           //
           if(cache[value]){
               return cache[value]
           }
           let min = []
           let newMin
           let newAmout
           //对每个面额都计算newAmount的值，他的值会一直减少，直到找到零的最小钱数，若newAmount是合理的值，则会计算他的找零结果
           for(let i = 0;i<coins.length;i++){
               const coin = conins[i]
               newAmount = value - coin
               if(newAmount >=0){
                   newMin = makeChange(newAmount)
               }
               if(newAmount >=0 &&(newMin.length<min.length-1||!min.length)&&(newMin.length||!newAmount)){
                   min = [coin].concat(newMin)
                   console.log("new Min"+min+"for"+amount)
               }
           }
           return (cache[value]=min)
       }
       return makeChange(amount)
   }
   
   

5. 图的全源最短路径：对所有顶点对(u,v)，找出从顶点u到顶点v的最短路径