软件考试吧 关注:37,204贴子:188,935

有软件设计师对答案的没

只看楼主收藏回复

有软件设计师对答案的没


IP属地:河南来自Android客户端1楼2018-05-26 11:16回复


    IP属地:英国来自手机贴吧2楼2018-05-26 11:23
    回复
      2026-03-23 23:11:16
      广告
      不感兴趣
      开通SVIP免广告


      来自手机贴吧3楼2018-05-26 11:34
      回复
        怎么对


        IP属地:广东来自Android客户端4楼2018-05-26 11:36
        回复
          BBADB
          CDBAD
          ABBCB
          CDDBB
          CBADA
          CCBDC
          BCCCB
          BADCD
          CADCC
          BAACA
          DACAD
          ACDDB
          ABBDB
          BBCAA
          BBADB


          IP属地:河南来自Android客户端5楼2018-05-26 11:45
          收起回复
            有没有哪位培训机构的朋友有标准答案的。我估计我凉了,14点前请告诉我我凉了没。凉了下午就不去考场了


            IP属地:河南来自Android客户端6楼2018-05-26 11:45
            回复
              这种贴不会被删或者违法吧


              IP属地:河南来自Android客户端7楼2018-05-26 11:48
              回复
                看你的答案怕是凉了


                来自Android客户端8楼2018-05-26 11:48
                收起回复
                  2026-03-23 23:05:16
                  广告
                  不感兴趣
                  开通SVIP免广告
                  一首凉凉送给你。


                  IP属地:安徽来自Android客户端9楼2018-05-26 12:12
                  收起回复
                    第一题就错了楼主


                    IP属地:广东来自Android客户端10楼2018-05-26 12:25
                    收起回复
                      你们考试可以带答案出考场的吗


                      来自Android客户端12楼2018-05-26 13:21
                      回复
                        你怕是凉了


                        IP属地:山东来自iPhone客户端13楼2018-05-26 16:41
                        收起回复
                          哎,这样看真要凉啊,下午的觉得好难


                          16楼2018-05-26 23:28
                          收起回复
                            倒数第二题,类似:
                            动态规划算法:
                            而实际上我们不需要在每次都去重新计算cut_rod的在n=2时的结果,只需要在第一次计算的时候将结果保存起来,然后再需要的时候直接使用即可。这其实就是所谓的动态规划算法。
                            这里的思路有两种,一种叫带备忘的自顶向下方法,是顺着之前的代码,当需要的时候去检查是不是已经计算好了,如果是,则直接使用,如果不是,则计算,并保存结果。第二种思路是自底向上方法,不论需不需要,先将子问题一一解决,然后再来解决更一级的问题,但要注意的是,我们需要先从最小的子问题开始,依次增加规模,这样每一次解决问题的时候,它的子问题都已经计算好了,直接使用即可。
                            带备忘的自顶向下方法:
                            [cpp] view plain copy
                            int memoized_cut_rod_aux(int* p, int n, int* r) {
                            if (r[n] >= 0) {
                            return r[n];
                            }
                            int q = -1;
                            if (n == 0) {
                            q = 0;
                            } else {
                            for (int i = 1; i <= n; i++) {
                            q = max(q, p[i] + memoized_cut_rod_aux(p, n - i, r));
                            }
                            }
                            r[n] = q;
                            return q;
                            }
                            /*
                            * 自顶向上的cut-rod的过程
                            */
                            int memoized_cut_rod(int* p, int n) {
                            int* r = new int[n + 1];
                            //初始化r数组,r数组用来存放,某种解决方案的最大收益值,对于n长的钢条而言,有n+1种切割方案,所以数组n+1长
                            for (int i = 0; i <= n; i++) {
                            r[i] = -1;
                            }
                            return memoized_cut_rod_aux(p, n, r);
                            }
                            自底向上的方法:
                            [cpp] view plain copy
                            /*
                            * 自底向上的方式,先计算更小的子问题,然后再算较大的子问题,由于较大的子问题依赖于更小的子问题的答案,所以在计算较
                            * 大的子问题的时候,就无需再去计算更小的子问题,因为那答案已经计算好,且存储起来了
                            */
                            int bottom_up_cut_rod(int p[], int n) {
                            int* r = new int[n + 1];
                            r[0] = 0; //将r[0]初始化为0,是因为0长的钢条没有收益
                            for (int j = 1; j <= n; j++) {
                            int q = -1;
                            /*
                            * 这里不用i=0开始,因为i=0开始不合适,因为这里总长就是为j,而划分是i和j-i的划分,如果i等于0,那么
                            * 就意味着要知道r[j-0]=r[j]的值也就是j长的最好划分的收益,但是我们这里不知道。而且对于p[0]而言本身就没有意义
                            * p数组中有意义的数据下标是从1到n的
                            */
                            for (int i = 1; i <= j; i++) {
                            q = max(q, p[i] + r[j - i]); //
                            }
                            r[j] = q;
                            }
                            return r[n];
                            }
                            上面两种算法的时间复杂度都是O(n^2)。


                            IP属地:广东18楼2018-05-27 07:23
                            回复(6)
                              2026-03-23 22:59:16
                              广告
                              不感兴趣
                              开通SVIP免广告
                              ER图我也来一个
                              第一题是实体配送员、托运公司、订单整体框通过联系运送连在一起,联系类型是*:*:*
                              第二题……忘了题干了,反正就是把说明里的属性填进去,再把1方主键并入多方。
                              第三题:顾客引一条线出来和弱实体"顾客地址"相连,然后运送联系原本连接到订单整体框的那条线改连到顾客地址上,联系类型多对多对多不变。
                              逻辑关系里把订单编号改为顾客地址……


                              IP属地:四川来自Android客户端22楼2018-05-27 12:36
                              收起回复