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

本文链接：https://blog.youkuaiyun.com/Gelxgx/article/details/108535880

一些算法的设计

分而治之

分成三部分：

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

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

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

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

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)
    
}

动态规划

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

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

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

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

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

他描述为：给一个固定大小，能够携重量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]
}

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

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

//最长公共子序列算法
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]
}

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

这个问题是要找出矩阵相乘的最佳方式，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]
}
```

硬币找零：给出面额为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)
}