精华内容
下载资源
问答
  • 当你遇到了问题,不管它是什么类型的什么方面的,切记!最终的根源是因为人的问题。兵书上云:攻城为下,攻心为上。不战而屈人之兵是怎样的一个境界呀。 

    当你遇到了问题,不管它是什么类型的什么方面的,切记!最终的根源都是因为人的问题。兵书上云:攻城为下,攻心为上。不战而屈人之兵是怎样的一个境界呀。

     

    展开全文
  • 0x01....如果没有任何一种硬币组合能组成总金额,返回 -1。 输入示例:1 2 5 11 输出示例:3 函数形式为:int coinChange1(int* coins, int coinsSize, int amount) 0x02.分析问题 这个...

    0x01.问题

    给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额,返回 -1。

    输入示例:1 2 5 11

    输出示例:3 

    函数形式为: int coinChange1(int* coins, int coinsSize, int amount)

    0x02.分析问题

     这个问题的子问题仍然是一定金额所需的硬币最小数,不过金额会越来越少,这些子问题之间相互独立,可以看出,这是一个动态规划问题。

    我们需要根据金额的大小来计算其所需的最小硬币,可以根据金额的大小来动态计算,也就是以金额为动态规划的状态。

    我们可以先思考一下最简单粗暴的暴力递归方法,例如,我们要计算11,那么我们可以先从硬币中取一枚,等于占用了一枚 ,例如取出1,然后就只需要计算金额为10的最小硬币数,当金额为0时,就是0,当金额小于0时,这种方法行不通,计为-1。

    有了这个思路,我们可以得到第一种暴力递归的方法。

    0x03.解决办法1--暴力递归

    int coinChange(int* coins, int coinsSize, int amount) {
        if (amount < 0)
            return -1;
        if (amount == 0)
            return 0;
        int min = 65535;
        int temp;
        for (int i = 0; i < coinsSize; i++)
        {
            temp = coinChange1(coins, coinsSize, amount - coins[i]);
            if (temp == -1)
                continue;
            min = min < (temp + 1) ? min : (temp + 1);
        }
        if (min != 65535)
        {
            return min;
        }
        else
        {
            return -1;
        }
    }

    的确可以通过测试用例,但时间复杂度实在是太高了,肯定AC不了这个问题。

    仔细一想,时间复杂度达到了恐怖的指数级,这个当然不得行。

    我们再次思考一下,时间复杂度那么高得原因是啥,重复调用呗,在上篇博客也提到过,不清楚得话可以画一下递归树,会发现存在大量得递归调用。

    那么相应得,我们得解决思路也出来了,就是借用一个标志变量,去记录已经计算出的值。

    0x04.解决办法2--记忆化搜索

    int coinChange(int* coins, int coinsSize, int amount) {
        if (amount < 0)
            return -1;
        if (amount == 0)
            return 0;
        int* flag = (int*)calloc(amount+1, sizeof(int));
        return checker(flag, amount, coins, coinsSize);
    }
    
    int checker(int* flag, int amount,int *coins,int coinsSize)
    {
        if (amount == 0)
            return 0;
        if (amount < 0)
            return -1;
        if (flag[amount])
            return flag[amount];
        int min = 65535;//初始化为一个比较大的值
        for (int i = 0; i < coinsSize; i++)
        {
            int temp = checker(flag,amount - coins[i],coins,coinsSize);
            if (temp == -1)
                continue;
            min = min < (temp + 1) ? min : (temp + 1);
        }
        if (min != 65535)
        {
            flag[amount] = min;
            return min;
        }
        else
        {
            flag[amount] = -1;
            return -1;
        }
    }

    这样时间复杂度就降下来了,设长度是S,硬币的种数是n,那么时间复杂度是 O(S*n),空间复杂度为 O(S)。

    这其实也可以看作是自上而下的动态规划。

    0x05.解决办法3--动态规划(自下而上)

    我们首先需要找一下初始条件,很明显,就是 dp[0]=0。

    由于在迭代的过程中需要不断的寻找最小值,所有可以把dp里面的值都初始化为一个较大的值,比如amount+1,是无法达到的。

    然后就是自下而上的迭代条件了:

    DP[I]=min{DP[i],DP[i-coin]+1},DP[i]表示金额为 i 需要的最少硬币数。

    下面来看一下C++代码:

    int coinChange(vector<int>& coins, int amount)
    {
        vector<int> dp(amount + 1, amount + 1);
        dp[0] = 0;
        for (int i = 0; i < dp.size(); i++)
        {
            for (int coin : coins)
            {
                if (i < coin) continue;
                dp[i] = min(dp[i], dp[i - coin] + 1);
            }
        }
        return (dp[amount] != amount + 1) ? dp[amount] : -1;
    }

    C代码:

    int coinChange(int* coins, int coinsSize, int amount) {
        int* dp = (int*)calloc(amount + 1, sizeof(int));
        int i, j;
        for (i = 0; i <= amount; i++)
        {
            dp[i] = amount + 1;
        }
        dp[0] = 0;
        for (i = 0; i <= amount; i++)
        {
            for (j = 0; j < coinsSize; j++)
            {
                if (i < coins[j]) continue;
                dp[i] = dp[i] < dp[i - coins[j]] + 1 ? dp[i] : dp[i - coins[j]] + 1;
            }
        }
        return (dp[amount] != amount + 1) ? dp[amount] : -1;
    }

    0x06.探索动态规划的基本思想

    什么问题可以用动态规划解决?

    • 存在最优子结构,子问题相互独立。
    • 遇到找不到最优子结构时,可以适当变换问题思路再来寻找。
    • 巧妙的抓住,最值 这个关键字。

    解决动态规划问题可尝试的基本思路?

    • 如果一下子无法找到动态规划的关键,可以一步一步的去尝试。
    • 可以先用最简单的思路写出暴力递归的方法。
    • 然后用标志变量,记忆化搜索。
    • 最后,找到合适的动态规划思路。

    动态规划的基本步骤?

    1. 找准状态,简单来说,就是 DP[i] 的含义,你赋予它什么含义,就是什么含义。
    2. 找到状态转移方程,也就是迭代表达式,通常可以用具体的数据去打开你的思维。
    3. 找到基准条件,也就是初始条件,自下而上的一般是前几个值,自上而下的一般是后几个值。
    4. 使用合适的循环条件,将这一思想用代码呈现出来。

    动态规划的dp遍历方向?

    • 一般来说两种都可以,也可以斜向遍历。
    • 具体看哪种方向,基准条件好找。
    • 你需要保证在你遍历时,你所用到之前的条件已经被正确计算。
    • 你需要保证你遍历的末尾,就是你所需要的答案。

     

    你还可以继续阅读:零钱兑换II--动态规划思路解决相似问题

    如果本文对你有帮助,请分享给你的朋友吧!

    ATFWUS  --Writing  By 2020--03--14

    展开全文
  • 完全背包问题----思想的理解

    千次阅读 2016-08-10 19:42:48
    最近学习动态规划,在背包问题处被卡了很久,故在此处把这几天的遇到的问题和自己的理解进行一下总结。...1.在《算法竞赛入门经典》中,其对完全背包问题是通过DAG的思想来讨论的。先讨论了完全背包问题,再推广

    最近学习动态规划,在背包问题处被卡了很久,故在此处把这几天的遇到的问题和自己的理解进行一下总结。


    这篇博文主要介绍的是完全背包的思想,包括它的三种状态转移方程。作为引入完全背包问题的前提,附带的介绍了DAG思想和01背包问题。

    参考资料有《算法竞赛入门经典》和《背包九讲》。


    1.在《算法竞赛入门经典》中,其对完全背包问题是通过DAG的思想来讨论的。先讨论了完全背包问题,再推广到01背包问题。

    2.在《背包九讲》中,讨论顺序相反,其对完全背包的讨论是通过01背包的思想推广而来。


    一、先来理解《算法竞赛入门经典》的思想。

    在看完全背包问题时先来看一个硬币问题。描述如下:

    有n中硬币,每种硬币的面值为v1,v1......vn.且每种硬币有无限多。现在给定一个非负整数S,可以选用多少个硬币,使得面值之和恰好为S。输出硬币数目的最小值和最大值。


    分析:如何通过建图求解

    把要凑足的总面值看成一个个点。起点为S,终点为0. 

    那么什么样的两个点是联通的呢?很显然点i到点i-vj(i>=vi)是联通的。取硬币j,状态就由i转移到了i-vj,点i与i-vj联通说面这两点之间有一条线。

    很显然,从点i出发的线可能是0条,也可能不止一条。

    我们现在的问题就变成了从点S到点0,最长的路径和最短的路径。


    定义的d[i]为面值之和为i时最大的硬币数目。则有:

    d[i] = max(d[i-v[j]]+1)   j : 0->n  且   i-v[j]>=0

    这个方程叫做状态转移方程。

    那么我们是如何来考虑这个状态转移的过程的呢?

    即在图中,我们是如何决定,在所有与i联通的点中,选择哪一个点。很显然应该取使d[i-v[j]]最大的那个j.


    伪代码如下

    (是从硬币的面值总额来考虑这个问题)

    d[0] = 0

    for j:1->S  d[j] =-INF    //因为此题要求恰好取到S,要用一个特殊值去表示不能取到的值,否则的话里面是数组随意赋予的值

    for  i:1->S

        do  for j:1->n

                if(v[j]<=i && d[i]<d[i-v[j]]+1)d[i] = d[i-v[j]]+1;  



    PA:注意此处两层循环的顺序,第一层循环是对总价值的循环,第二次循环是对硬币种类的循环。《背包九讲》中会把两层循环的顺序改变。


    有这个问题来看待完全背包问题,问题描述:

    有n种背包,每个包有体积vj重量wj两个属性,每种背包有无穷多个。现有体积为C的大包,问如何装能使大包的重量最大。


    分析:

    多了一个重量属性,想当于边上有了权值,之前权值为1,现在权值为Wj

    定义d[i]为装满体积为i的包是的最大重量

    d[i] = max{d[i-v[j]]+w[j]}


    二、接着来理解《背包九讲》中的思想

    先来看一下01背包问题,描述如下:

    有n种背包,每个包有体积vj重量wj两个属性,每种背包只有一个。现有体积为C的大包,问如何装能使大包的重量最大。


    这个时候我们重新来定义一下状态转移方程。

    d[i][j] 表示取前i种包装到体积为j的包中时所能达到的最大重量,则有:

    d[i][j] =max{ d[i-1][j],d[i-1][j-c[i]]+w[i]}

    其实这个转移方程也很好理解,无非就是有i-1种包转移到i种包时,第i个包到底取不取的问题。

    伪代码如下:

    d[0][i] =0;

    d[i][0] =0;

    for  i:1->n

        do  for  j:c[i]->C

              d[i][j] = max{d[i-1][j],d[i-1][j-c[i]]+w[i]}


    对以上代码可以把的d优化为一维的数组

    伪代码如下:

    d[0....C] =0;

    for  i:1->n

       do   for  j:C->c[i]          (注意j历遍的顺序变了,上面的伪代码是由c[i]->C,而这里的伪代码是由C->c[i])

            d[j] = d[j] >d[j-c[i]]]+w[i]?d[j]:d[j-c[i]]]+w[i]


    如何由一维数组到二维数组的呢?

    在二维数组的情况中,对于i的每一个值,都能算出一个d[i,0.....C]与其对应。那么,能否保证第i次循环后,d[v]是d[i][v]的值呢?

    d[i][v]是由d[i-1][v],d[i-1][v-c[i]]+w[i]递推得到的.所以要保证在第i次循环的时候,d[v]中的值是d[i-1,v]的值。

    j变为逆序就可以满足上述条件。(如果难以理解,最好上机调试单步查看结果)


    也可以这么理解,第i次循环,d[v]的更新由上一次的d[v]和d[v-c[i]]中的值来决定,所以d[v]要在d[v-c[i]]前更新。

    如果是由c[i]到C的顺序执行,则d[v-c[i]]一定会在d[v]前面更新,这是更新d[v]时d[v-c[i]]中的值已经是d[i,v-c[i]],而不是d[i-1,v-c[i]]了。


    由01背包问题到完全背包问题:

    首先看二维的方式,二维的时候很好定义状态转移方程

    d[i][j]仍是前i种背包装入到j体积中时的最大重量,那么

    d[i][j] = max{d[i][j-k*c[i]]+k*c[i]},    k:0->j/c[i]


    同样二维的可以简化为一

    伪代码如下:

    d[0....C] =0;

    for  i:1->n

       do   for  j:c[i]->C         (注意此时j的历遍顺序恰好和01背包相反,而此时两个for循环的顺序与《算法竞赛入门》中for循环的顺序恰好相反,

                                           《背包九讲》里也提到两个for循环的顺序可以互换,就在此处体现。要注意不是任何情况是两个for循环都可以替换,

                                       如UVA674硬币找零问题, 后面会有专门的文章总结。)

            d[j] = d[j] >d[j-c[i]]]+w[i]?d[j]:d[j-c[i]]]+w[i]



    展开全文
  • 背包问题与动态规划的基本思想

    万次阅读 2013-10-24 20:11:15
    网上有很多关于背包问题和动态规划的代码实现文章,但是如何理解动态规划的思想才是最关键的,尤其如何理解成这是一个多阶段的决策过程尤为重要,下面的这个动态规划讲解非常好,主要从两个思路来讲解动态规划,一个...

    网上有很多关于背包问题和动态规划的代码实现文章,但是如何理解动态规划的思想才是最关键的,尤其如何理解成这是一个多阶段的决策过程尤为重要,下面的这个动态规划讲解非常好,主要从两个思路来讲解动态规划,一个是利用物品个数和背包容量来说明阶段间关系,即“前i-1件物品放入剩下的容量为v-c[i]的背包中”;另一个就是直接从背包容量角度去考虑价值,新增的容量所带来的不同价值,记录各个物品新增所造成的价值变化,虽然抽象,但空间复杂度少很多。很多组合优化问题都可以归结背包问题,因为很多问题本质是因设备能力有限所造成的的瓶颈带来求解困难。

     

    题目

    有N件物品和一个容量为V的背包。第i件物品的费用是c[i],价值是w[i]。求解将哪些物品装入背包可使价值总和最大。

    基本思路

    这是最基础的背包问题,特点是:每种物品仅有一件,可以选择放或不放。

    用子问题定义状态:即f[i][v]表示前i件物品恰放入一个容量为v的背包可以获得的最大价值。则其状态转移方程便是:

    f[i][v]=max{f[i-1][v],f[i-1][v-c[i]]+w[i]}

    这个方程非常重要,基本上所有跟背包相关的问题的方程都是由它衍生出来的。所以有必要将它详细解释一下:“将前i件物品放入容量为v的背包中”这个子问题,若只考虑第i件物品的策略(放或不放),那么就可以转化为一个只牵扯前i-1件物品的问题。如果不放第i件物品,那么问题就转化为“前i-1件物品放入容量为v的背包中”,价值为f[i-1][v];如果放第i件物品,那么问题就转化为“前i-1件物品放入剩下的容量为v-c[i]的背包中”,此时能获得的最大价值就是f[i-1][v-c[i]]再加上通过放入第i件物品获得的价值w[i]。

    优化空间复杂度

    以上方法的时间和空间复杂度均为O(VN),其中时间复杂度应该已经不能再优化了,但空间复杂度却可以优化到O。

    先考虑上面讲的基本思路如何实现,肯定是有一个主循环i=1..N,每次算出来二维数组f[i][0..V]的所有值。那么,如果只用一个数组f[0..V],能不能保证第i次循环结束后f[v]中表示的就是我们定义的状态f[i][v]呢?f[i][v]是由f[i-1][v]和f[i-1][v-c[i]]两个子问题递推而来,能否保证在推f[i][v]时(也即在第i次主循环中推f[v]时)能够得到f[i-1][v]和f[i-1][v-c[i]]的值呢?事实上,这要求在每次主循环中我们以v=V..0的顺序推f[v],这样才能保证推f[v]时f[v-c[i]]保存的是状态f[i-1][v-c[i]]的值。伪代码如下:

    for i=1..N for v=V..0 f[v]=max{f[v],f[v-c[i]]+w[i]};

    其中的f[v]=max{f[v],f[v-c[i]]}一句恰就相当于我们的转移方程f[i][v]=max{f[i-1][v],f[i-1][v-c[i]]},因为现在的f[v-c[i]]就相当于原来的f[i-1][v-c[i]]。如果将v的循环顺序从上面的逆序改成顺序的话,那么则成了f[i][v]由f[i][v-c[i]]推知,与本题意不符,但它却是另一个重要的背包问题P02最简捷的解决方案,故学习只用一维数组解01背包问题是十分必要的。

    事实上,使用一维数组解01背包的程序在后面会被多次用到,所以这里抽象出一个处理一件01背包中的物品过程,以后的代码中直接调用不加说明。

    过程ZeroOnePack,表示处理一件01背包中的物品,两个参数cost、weight分别表明这件物品的费用和价值。

    procedure ZeroOnePack(cost,weight) for v=V..cost f[v]=max{f[v],f[v-cost]+weight}

    注意这个过程里的处理与前面给出的伪代码有所不同。前面的示例程序写成v=V..0是为了在程序中体现每个状态都按照方程求解了,避免不必要的思维复杂度。而这里既然已经抽象成看作黑箱的过程了,就可以加入优化。费用为cost的物品不会影响状态f[0..cost-1],这是显然的。

    有了这个过程以后,01背包问题的伪代码就可以这样写:

    for i=1..N ZeroOnePack(c[i],w[i]);初始化的细节问题

    我们看到的求最优解的背包问题题目中,事实上有两种不太相同的问法。有的题目要求“恰好装满背包”时的最优解,有的题目则并没有要求必须把背包装满。一种区别这两种问法的实现方法是在初始化的时候有所不同。

    如果是第一种问法,要求恰好装满背包,那么在初始化时除了f[0]为0其它f[1..V]均设为-∞,这样就可以保证最终得到的f[N]是一种恰好装满背包的最优解。

    如果并没有要求必须把背包装满,而是只希望价格尽量大,初始化时应该将f[0..V]全部设为0。

    为什么呢?可以这样理解:初始化的f数组事实上就是在没有任何物品可以放入背包时的合法状态。如果要求背包恰好装满,那么此时只有容量为0的背包可能被价值为0的nothing“恰好装满”,其它容量的背包均没有合法的解,属于未定义的状态,它们的值就都应该是-∞了。如果背包并非必须被装满,那么任何容量的背包都有一个合法解“什么都不装”,这个解的价值为0,所以初始时状态的值也就全部为0了。

    这个小技巧完全可以推广到其它类型的背包问题,后面也就不再对进行状态转移之前的初始化进行讲解。

    一个常数优化

    前面的伪代码中有 for v=V..1,可以将这个循环的下限进行改进。

    由于只需要最后f[v]的值,倒推前一个物品,其实只要知道f[v-w[n]]即可。以此类推,对以第j个背包,其实只需要知道到f[v-sum{w[j..n]}]即可,即代码中的

    for i=1..N for v=V..0

    可以改成

    for i=1..n bound=max{V-sum{w[i..n]},c[i]} for v=V..bound

    这对于V比较大时是有用的。

    小结

    01背包问题是最基本的背包问题,它包含了背包问题中设计状态、方程的最基本思想,另外,别的类型的背包问题往往也可以转换成01背包问题求解。故一定要仔细体会上面基本思路的得出方法,状态转移方程的意义,以及最后怎样优化的空间复杂度。

    展开全文
  • 浅谈用极大化思想解决最大子矩阵问题

    千次阅读 多人点赞 2016-01-17 16:34:06
     本文针对一类近期经常出现的有关最大(或最优)子矩形及相关变形问题,介绍了极大化思想在这类问题中的应用。分析了两个具有一定通用性的算法。并通过一些例题讲述了这些算法选择和使用时的一些技巧。   ...
  • 1.问题描述八皇后问题是一个以国际象棋为背景的问题:如何能够在 8×8 的国际象棋棋盘上放置八个皇后,使得任何一个皇后无法直接吃掉其他的皇后?为了达到此目的,任两个皇后不能处于同一条横行、纵行或斜线上。...
  • 问题 有 1000 个一模一样的瓶子,其中有 999 瓶是普通的水,有一瓶是毒药。任何喝下毒药的生物都会在一星期之后死亡。现在,你只有 10 只小白鼠和一星期的时间,如何检验出哪个瓶子里有毒药? 解决方法 步骤一:给这...
  • 浅谈用极大化思想解决最大子矩形问题

    千次阅读 多人点赞 2012-10-28 10:16:46
     本文针对一类近期经常出现的有关最大(或最优)子矩形及相关变形问题,介绍了极大化思想在这类问题中的应用。分析了两个具有一定通用性的算法。并通过一些例题讲述了这些算法选择和使用时的一些技巧。   ...
  • 2.JAVA编程思想——一切是对象

    万次阅读 2016-04-02 00:18:13
    一切是对象 欢迎转载,转载请标明出处...在 Java 里,任何东西可看作对象。可采用一种统一的语法,任何地方均可照搬不误。注意,尽管将一切“看作”对象,但操纵的标识符实际是指向一个对象的“句柄”(Handle)
  • 用栈的思想分析火车进站出站问题

    万次阅读 多人点赞 2012-10-02 12:39:32
    解题思路:栈具有先进后出、后进先出的特点,因此,任何一个调度结果应该是1 ,2 ,3 ,4 全排列中的一个元素。由于进栈的顺序是由小到大的,所以出栈序列应该满足以下条件:对于 序列中的任何一个数其后面所有比...
  • 最短路径问题---Dijkstra算法详解

    万次阅读 多人点赞 2017-03-08 16:42:46
    前言 Nobody can go back and start a new beginning,but anyone can start today and make a new ending. Name:Willam Time:2017/3/8 1、最短路径问题介绍 问题解释: ...解决问题的算法:...
  • 编程思想

    千次阅读 2018-11-07 11:14:13
    一句话来讲就是,用计算机来解决人们实际问题的思维方式,即编程思想。 我们学习编程语言的最终目的,就是希望用计算机来解决我们的实际问题。那么学习计算机该如何入手,也是很多初学者犯难的一个问题,特别是对与...
  • Java基础问题整理

    万次阅读 多人点赞 2020-04-07 11:44:14
    备注:针对基本问题做一些基本的总结,不是详细解答! 1.HashMap和ConcurrentHashMap区别(必考) 2. ConcurrentHashMap的数据结构(必考) 3.高并发HashMap的环是如何产生的 4.HashMap1.7与HashMap1.8的区别,...
  • 分而治之的思想

    千次阅读 2018-07-20 09:17:16
    分治 分治(Divide and Conquer)是一种算法范式,也是一种解决问题思想。...任何一个可以用计算机求解的问题,所需的计算时间与其规模有关。 问题的规模越小,越容易直接求解,所需的计算时间也越少...
  •   算法思想有很多,业界公认的常用算法思想有8种,分别是枚举、递推、递归、分治、贪心、试探法、动态迭代和模拟。当然8种只是一个大概的划分,是一个...枚举算法思想的最大特点是,在面对任何问题时它会...
  • 什么是面向对象的编程思想

    千次阅读 2019-01-05 08:23:38
    面向对象的编程产生的历史原因:由于面向过程编程在构造系统时,无法...面向对象的编程的主要思想是把构成问题的各个事物分解成各个对象,建立对象的目的不是为了完成一个步骤,而是为了描述一个事物在解决问题的...
  • 面向对象思想总结

    万次阅读 多人点赞 2018-07-23 17:31:53
    面向对象和面向过程的思想有着本质上的区别,作为面向对象的思维来说,当你拿到一个问题时,你分析这个问题不再是第一步先做什么,第二步再做什么,这是面向过程的思维,你应该分析这个问题里面有哪些类和对象,这是...
  • 参数估计:贝叶斯思想和贝叶斯参数估计

    万次阅读 多人点赞 2016-05-23 10:54:29
    http://blog.csdn.net/pipisorry/article/details/51471222贝叶斯与频率派思想频率派思想 长久以来,人们对一件事情发生或不发生,只有固定的0和1,即要么...比如如果问那时的人们一个问题:“有一个袋子,里面装着
  • 编程思想和网络协议处理

    千次阅读 2014-04-12 09:05:14
    2.最近在实现一个协议如何判断一段数据是一个IP数据报,这个问题很简单,但是暴露的却是一个大问题。引发的是更多的思想。3.OpenSSL的心脏流血一个数据包的包头长度字段标识的长度并不是数据包的真实长度,关键是你...
  • 工程化的思想

    千次阅读 热门讨论 2014-11-22 17:42:22
    工程化的思想 工程这一词:  最先了解“工程”这一词是从建设、建筑方面有所听闻,建筑工程、项目工程,水利工程、化学工程、土木工程、生物工程等的,之后接触了“软件工程”——是自己详细的学习和了解的一个...
  • 面试官你好:我们公司本身的业务体量很小,所以直接单机一把梭啥能搞定了,但是后面业务体量不断扩大,采用微服务的设计思想,分布式的部署方式,所以拆分了很多的服务,随着体量的增加以及业务场景越来越复杂了...
  • 最大流问题

    千次阅读 2016-09-06 16:45:15
    举例描述最大流问题是一个很经典的问题,很多人对此也很熟悉,它能够等同于一个线性规划问题。下面给出最大流问题的一个基本描述:如下图所示,s是源点,t为汇点,每条边上数字的含义是边能够允许流过的最大流量。...
  • 一位十年软件工程师告诉你什么是编程思想

    万次阅读 多人点赞 2011-09-27 00:46:01
    一句话来讲就是,用计算机来解决人们实际问题的思维方式,即编程思想。  我们学习编程语言的最终目的,就是希望用计算机来解决我们的实际问题。那么学习计算机该如何入手,也是很多初学者犯难的一个问题,特别是对...
  • 我的管理思想

    万次阅读 2013-11-17 11:36:13
    我的管理思想一、中国古代哲学对我管理思想的影响我也是受中国传统哲学思想学习长大。中国主流儒学讲究仁(孔子)义(孟子),四大名著《三国》突出仁(火烧新野)义(千里走单骑/火烧连营)、《水浒》突出仁(替...
  • 有限元方法的核心思想是什么?

    万次阅读 2016-07-27 17:46:43
    有限元方法的核心思想是什么? 有限元方法似乎是在不断地简化着什么。 请问有限元方法的核心思想是什么?在哪些层面对方程做了简化?每一次简化的依据和思路是什么? 2 条评论 按投票排序...
  • 前端组件化思想

    万次阅读 多人点赞 2018-02-27 09:59:14
      是的,前端越来越简单了,但也越来越复杂了—简单到你可以用一个Github的starter搭建一个框架,集成所有的全家桶,涵盖单元测试和功能测试,包括部署以及发布,甚至你开发时使用的UI库让你写不了几行c...
  • 透彻理解高斯核函数背后的哲学思想与数学思想

    万次阅读 多人点赞 2019-02-03 10:27:51
    简单性的哲学思想实质上就是,我们坚持寻找线性可分的转换问题,即变换数据,让它们线性可分,而变换数据的方法就是由低维到多维特征的一个特征空间变换。 从有限到无限的哲学思想 哲学中的有限和无限是对立...
  • 一、问题来因 今天在整合项目时需要将码云上的仓库clone... 二、寻找解决方案 开始在CSDN上找各种解决办法,并没有任何成果,遇到的问题情况和我不一样。 我一直秉承的思想问题不能只有解决了才行,我们应该去...
  • 皇后问题

    万次阅读 多人点赞 2018-11-29 15:44:55
    八皇后问题是一个以国际象棋为背景的问题:如何能够在 8×8 的国际象棋棋盘上放置八个皇后,使得任何一个皇后无法直接吃掉其他的皇后?为了达到此目的,任两个皇后不能处于同一条横行、纵行或斜线上。八皇后问题...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 458,009
精华内容 183,203
关键字:

任何问题都是思想问题