习题9-3（切蛋糕）【深搜dfs】+【记忆化搜索】

最新推荐文章于 2024-07-14 17:53:34 发布
最新推荐文章于 2024-07-14 17:53:34 发布
阅读量1.1k 收藏 1
点赞数 1
分类专栏： 紫书第九章 文章标签： uva dfs 搜索 紫书 记忆化
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iWiggins/article/details/54730834
版权
一道来自UVa 1629的切蛋糕问题，要求在n行m列的蛋糕上用最少的切割次数使得每一块都含有一个樱桃。解决方案通过深度优先搜索（DFS）配合记忆化搜索来优化，通过dp矩阵记录已搜索区域的最优解。在搜索过程中，判断区域樱桃数量并进行转移计算，最终实现一次AC。
摘要由CSDN通过智能技术生成

习题9-3

【UVa 1629】Cake Slicing（切蛋糕）

题目大意：

有一个n行m列(1<=n,m<=20)的网格蛋糕上有一些樱桃。每次可以用一刀沿着网格线把蛋糕切成两块，并且只能够直切不能拐弯。要求最后每一块蛋糕上恰好有一个樱桃，且切割线总长度最小。

思路：

刚看到这道题的时候因为有了前两题的经验就往记忆化搜索那边靠，一下就想到了搜索思路：dp[x][y][xlen][ylen]表示以(x,y)为起点的分别以xlen,ylen为边长的矩形区域的最优解，这样就可以横着切每条网格线和纵着切每条网格线，对于每个搜索到的区域，如果之前没访问过，那么首先要判断此区域是否存在樱桃，有几个，如果没有则可以直接返回一个极大值抛弃这种情况，如果只有一个那就是末状态了，返回0，表明这一块的最小值为0，如果有多于1个，继续切割，每次转移时考虑切下来的两块的最优值加上切这一刀的花费。
转移方程：dfs(x,y,xlen,ylen)=min(dfs(x,y,xlen,ylen)，dfs(x,y,i-x+1,ylen)+ylen+dfs(i+1,y,xlen-(i-x+1),ylen)，dfs(x,y,xlen,j-y+1)+xlen+dfs(x,j+1,xlen,ylen-(j-y+1)));

tips:在dfs时可以用一个引用代表dp[][][][],既可省力又能使代码美观

代码：


                

                
                
        

        

    

  


        

            

                    
                      最低0.47元/天 解锁文章
                        
                    
            

        

    

      

        

            

              
                
                  iWiggins
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
切蛋糕笔试题

				
			

			

				

					chuomei5332的博客
				

				

					09-28
					
					1141
					
				

			

		

		

			
				
题目描述
小明请了k个小朋友来给他过生日，小明手头有若干块等宽的长条形的蛋糕，长度分别是a[0]. a[1], … a[N-1],为此他需要准备k块长度样的切片蛋糕，而且希望每个小朋友分到的蛋糕尽量多:
1.所有蛋糕长度均为正整数
2.我们将蛋糕切分为任意正整数长度的小块。
3.可以丢弃部分或者全部原始蛋糕。
4.可以丢弃原始蛋糕切剩下的部分。
输入描述:
第一行有两个整数， 第一个整数N表示有多少原始蛋糕，第二个整数k表示有多少个小朋友参加生日。其中(1<=N<=1e5, k可由64位无符号整

			
		

	



                

              
                



	

		

			

				
					
切蛋糕（招行笔试）

				
			

			

				

					勤学如春起之苗，不见其增，日有所长
				

				

					03-19
					
					293
					
				

			

		

		

			
				
题意：
把蛋糕切整齐，每次切的体积不超过k.
参考：
https://www.nowcoder.com/discuss/164334?type=1
每次下降一个高度，计算当前累积的cut。当大于k时，跳出循环，cuth+1,切掉所有大于cuth的蛋糕。
#include<iostream>
#include<vector>
#include<algorithm>...

			
		

	



                


  
              

                


	

		

			

				
					
【vjios】【DFS】切蛋糕

				
			

			

				

					weixin_30587927的博客
				

				

					11-13
					
					121
					
				

			

		

		

			
				
描述

Facer今天买了n块蛋糕，不料被信息组中球球等好吃懒做的家伙发现了，没办法，只好浪费一点来填他们的嘴巴。他答应给每个人留一口，然后量了量每个人口的大小。Facer有把刀，可以切蛋糕，但他不能把两块蛋糕拼起来，但是他又不会给任何人两块蛋糕。现在问你，facer怎样切蛋糕，才能满足最多的人。（facer的刀很强，切的时候不会浪费蛋糕）。



格式



输入格式

第一...

			
		

	





	

		

			

				
					
【算法每日一练]-单调队列 篇3 琪露诺 ，选数游戏 ，寻找段落 ，切蛋糕，新月轩就餐

					
最新发布

				
			

			

				

					m0_69478376的博客
				

				

					07-14
					
					642
					
				

			

		

		

			
				
最后一期单调队列

			
		

	



		

			
		



	

		

			

				
					
Dfs:切蛋糕

				
			

			

				

					Claire的博客
				

				

					03-16
					
					177
					
				

			

		

		

			
				
深搜：下棋，找路
例如，下棋情况下，一个棋局对应一个点，一个棋局出发走了一步到了另一个棋局，从当前的局面出发，每一条选择都会走到不同的节点，往前，之后要对方有多少走法，之后又要考虑到对方走了这一步，我要怎么走的可能性。
生日蛋糕
题目
Description

7月17日是Mr.W的生日，ACM-THU为此要制作一个体积为Nπ的M层生日蛋糕，每层都是一个圆柱体。
设从下往上数第i(1 <= ...

			
		

	





	

		

			

				
					
【题解】 切蛋糕

				
			

			

				

					cjx的博客
				

				

					08-21
					
					1573
					
				

			

		

		

			
				
题目来源：洛谷
题目描述
今天是小Z的生日，同学们为他带来了一块蛋糕。这块蛋糕是一个长方体，被用不同色彩分成了N个相同的小块，每小块都有对应的幸运值。
小Z作为寿星，自然希望吃到的第一块蛋糕的幸运值总和最大，但小Z最多又只能吃M小块(M≤N)的蛋糕。
吃东西自然就不想思考了，于是小Z把这个任务扔给了学OI的你，请你帮他从这N小块中找出连续的k块蛋糕(k≤M)，使得其上的幸运值最大。
输入格式
输入...

			
		

	





	

		

			

				
					
习题9-2（免费糖果）【深搜dfs】+【记忆化搜索】

				
			

			

				

					orzAC--算法代码园
				

				

					01-25
					
					508
					
				

			

		

		

			
				
习题9-2【UVa 10118】Free Candies（免费糖果）题目大意：桌上有4堆糖果，每堆有N(N<=40)颗。佳佳有个最多可以装5颗糖果的小篮子。他每次选择一堆糖果，把最顶上的一颗拿到篮子里。如果篮子里有两颗颜色相同的糖果，佳佳就把他们从篮子里拿出来放到自己口袋里。如果篮子满了而里面又没有相同颜色的糖果，游戏结束，口袋里的糖果就归他了。当然，如果佳佳够聪明，他有可能把堆里的所有糖果都拿走。

			
		

	





	

		

			

				
					
python写程序求1-3+5-7+...-99+101的值-python基本练习

					
热门推荐

				
			

			

				

					weixin_37988176的博客
				

				

					11-01
					
					1万+
					
				

			

		

		

			
				
python基本练习### 1. 请使用python中的循环打印输出从1到100的所有奇数？```pythonfor i in range(1,101):  #注意这里是101，不是100if i%2==1:   #选择奇数print(i)```13579111315171921232527293133353739414345474951535557596163656769717375777981...

			
		

	





	

		

			

				
					
习题9-1（最长滑雪路径）【深搜dfs】+【记忆化搜索】

				
			

			

				

					orzAC--算法代码园
				

				

					01-25
					
					526
					
				

			

		

		

			
				
习题9-1【UVa 10285】longest Run on a Snowboard（最长滑雪路径）题目大意：
  在一个R*C（R,C<=100）的整数矩阵上找一条高度严格递减的最长路。起点任意，但每次只能沿着上下左右4个方向之一走一格，并且不能走出矩阵外。如图所示，最长路就是按照高度25,24,23，…，2,1这样走，长度为25。矩阵中的数均为0~100. 
  图：
1   2   3   4

			
		

	





	

		

			

				
					
函数习题(10)：递归方法求计算x-x2+x3-x4+…+(-1)n-1xn值

				
			

			

				

					weixin_45594995的博客
				

				

					04-09
					
					6085
					
				

			

		

		

			
				
#include<stdio.h>
#include<math.h>
float f(float x,int n);
int main()
{
    int n;
    float x;
    scanf("%f%d",&x,&n);
    printf("%.2f",f(x,n));
    return 0;
}
float f(float x,...

			
		

	





	

		

			

				
					
算法实践：切蛋糕(动态规划）

				
			

			

				

					matafeiyanll的博客
				

				

					03-26
					
					3899
					
				

			

		

		

			
				
切蛋糕
描述
有一块矩形蛋糕，宽和高分别是整数w、h。现要将其切成m块小蛋糕，每个小蛋糕都必须是矩形、且宽和高均为整数。切蛋糕时，每次切一块蛋糕，将其分成两个矩形蛋糕。请计算：最后得到的m块蛋糕中，最大的那块蛋糕的面积下限。

输入
共有多行，每行表示一个测试案例。
每行是三个用空格分开的整数w, h, m ，其中1 ≤ w, h, m ≤ 20 ， m ≤ wh.
当 w = h = m = 0...

			
		

	





	

		

			

				
					
切蛋糕题目

				
			

			

				

					weixin_39889618的博客
				

				

					03-10
					
					400
					
				

			

		

		

			
				
这是切蛋糕，思路就是先做排序，找出最大长度和宽度即可因为这里给的是vector，可能存在不是顺序，所以我们先排序，假如是set，则会默认的自动排序。

intmaxArea(inth,intw,vector<int>&horizontalCuts,vector<int>&verticalCuts){



sort(horizontalCuts.begin(),horizontalCuts.e...

			
		

	





	

		

			

				
					
切开蛋糕【dp+贪心】

				
			

			

				

					算法小猪的博客
				

				

					07-29
					
					906
					
				

			

		

		

			
				
题目描述
出于某些方面的需求，懒羊羊要把一块N×M的蛋糕切成一个个1×1的小蛋糕。
对于一块蛋糕，我们只能从某条横线或者某条竖线（要在方格线上），而且这蛋糕是不均匀的，从不同的线切割下去要花不同的代价。而且，对于一块蛋糕，切割一次以后就被分割成两块，而且不能把这两块蛋糕拼在一起然后一刀切成四块，只能两块分别再进行一次切割。
现在，给出从不同的线切割所要花的代价，求把整块蛋糕分割成1×1块小方块所需要耗费的最小代价。
输入
输入文件第一行包括N和M，表示长N宽M的矩阵。
第二行包括N-1个非负整数，分别表示沿

			
		

	





	

		

			

				
					
程序设计与算法（二）算法基础7.5分蛋糕

				
			

			

				

					M644695965的博客
				

				

					07-28
					
					740
					
				

			

		

		

			
				
程序设计与算法（二）算法基础7.5分蛋糕

			
		

	





	

		

			

				
					
HDU 4597（记忆化搜索 dfs 参考）

				
			

			

				

					
				

				

					05-09
					
					1232
					
				

			

		

		

			
				
HDU 4597（记忆化搜索 dfs 参考）

			
		

	





	

		

			

				
					
程序员的算法趣题Q55: 平分蛋糕

				
			

			

				

					chenxy_bwave的专栏
				

				

					10-15
					
					715
					
				

			

		

		

			
				
程序员的算法趣题Q55: 平分蛋糕 详细解题分析和python题解。题解有错，谁能帮助找出错在哪儿呢？

			
		

	





	

		

			

				
					
动态规划特训：切蛋糕（UVA1629）

				
			

			

				

					mavises的博客
				

				

					09-11
					
					1096
					
				

			

		

		

			
				
解题思路：利用动态规划的思想，这里的状态即是蛋糕的上线、下线、左线、右线。然后进行记忆化搜素。遍历竖着切的每一种方式和横着切的每一种方式最终得到结果。状态转移方程稍微有些繁琐，在这里就不列举了，可以直接看代码理解。

题目大意：给定一个方形蛋糕，上面有一些樱桃，现在可以对该蛋糕做切割处理，保证切出来的每一份小蛋糕上都有一个樱桃，且切割线的总长度最小。

Sample Input
3 4 3
1 2...

			
		

	





	

		

			

				
					
动态规划，记忆搜索，uva1629,切蛋糕

				
			

			

				

					A_Pathfinder的博客
				

				

					10-09
					
					395
					
				

			

		

		

			
				
先给链接：https://uva.onlinejudge.org/index.php?option=com_onlinejudge&amp;Itemid=8&amp;page=show_problem&amp;problem=4504

大意就是切n*m蛋糕，有k樱桃，只能横着竖着切，要求每一块蛋糕上恰好有一个樱桃，且割线总长最小。

Sample Input
3 4 3

1 2

2 3

3...

			
		

	





	

		

			

				
					
练习习题9-4，利用DNode.h，编写使用双向链表的程序，其中实现左插入、右插入，删除，显示等链表的功能。   2. 练习习题9-10，直接插入排序。  3. 练习习题9-12，选择排序。  4. 练习习题9-14，起泡排序。  5. 练习习题9-19，折半查找。

				
			

			

				

					05-25
				

			

		

		

			
				
以下是对应的代码实现：

1. 双向链表的实现：

DNode.h:

```c++
#ifndef DNODE_H
#define DNODE_H

template<typename T>
struct DNode{
    T data;
    DNode<T> *prior, *next;
    DNode(const T &d, DNode<T> *p = nullptr, DNode<T> *n = nullptr):data(d), prior(p), next(n){}
};

#endif //DNODE_H
```

双向链表的实现：

```c++
#include <iostream>
#include "DNode.h"

template<typename T>
class DList{
public:
    DList() : head(new DNode<T>(T())), size(0){}
    ~DList(){
        DNode<T> *p = head, *q;
        while(p){
            q = p->next;
            delete p;
            p = q;
        }
    }
    void insert(const T &d); // 右插入
    void leftInsert(const T &d); // 左插入
    bool remove(const T &d); // 删除
    bool empty() const { return size == 0; }
    void display() const;
private:
    DNode<T> *head;
    int size;
};

template<typename T>
void DList<T>::insert(const T &d){
    DNode<T> *p = head;
    while(p->next) p = p->next;
    DNode<T> *q = new DNode<T>(d, p, nullptr);
    p->next = q;
    ++size;
}

template<typename T>
void DList<T>::leftInsert(const T &d){
    DNode<T> *p = head->next;
    DNode<T> *q = new DNode<T>(d, head, p);
    head->next = q;
    if(p) p->prior = q;
    ++size;
}

template<typename T>
bool DList<T>::remove(const T &d){
    DNode<T> *p = head->next;
    while(p && p->data != d) p = p->next;
    if(!p) return false;
    p->prior->next = p->next;
    if(p->next) p->next->prior = p->prior;
    delete p;
    --size;
    return true;
}

template<typename T>
void DList<T>::display() const{
    DNode<T> *p = head->next;
    while(p){
        std::cout << p->data << " ";
        p = p->next;
    }
    std::cout << std::endl;
}
```

2. 直接插入排序：

```c++
#include <iostream>
#include <vector>

template<typename T>
void insertSort(std::vector<T> &arr){
    int n = arr.size();
    for(int i = 1; i < n; ++i){
        T tmp = arr[i];
        int j = i - 1;
        while(j >= 0 && arr[j] > tmp){
            arr[j+1] = arr[j];
            --j;
        }
        arr[j+1] = tmp;
    }
}

int main(){
    std::vector<int> arr{3, 5, 1, 4, 2};
    insertSort(arr);
    for(auto x : arr) std::cout << x << " ";
    std::cout << std::endl;
    return 0;
}
```

3. 选择排序：

```c++
#include <iostream>
#include <vector>

template<typename T>
void selectSort(std::vector<T> &arr){
    int n = arr.size();
    for(int i = 0; i < n-1; ++i){
        int k = i;
        for(int j = i+1; j < n; ++j){
            if(arr[j] < arr[k]) k = j;
        }
        if(k != i) std::swap(arr[i], arr[k]);
    }
}

int main(){
    std::vector<int> arr{3, 5, 1, 4, 2};
    selectSort(arr);
    for(auto x : arr) std::cout << x << " ";
    std::cout << std::endl;
    return 0;
}
```

4. 起泡排序：

```c++
#include <iostream>
#include <vector>

template<typename T>
void bubbleSort(std::vector<T> &arr){
    int n = arr.size();
    for(int i = 0; i < n-1; ++i){
        bool flag = false;
        for(int j = 0; j < n-1-i; ++j){
            if(arr[j] > arr[j+1]){
                std::swap(arr[j], arr[j+1]);
                flag = true;
            }
        }
        if(!flag) break;
    }
}

int main(){
    std::vector<int> arr{3, 5, 1, 4, 2};
    bubbleSort(arr);
    for(auto x : arr) std::cout << x << " ";
    std::cout << std::endl;
    return 0;
}
```

5. 折半查找：

```c++
#include <iostream>
#include <vector>

template<typename T>
int binarySearch(std::vector<T> &arr, const T &x){
    int l = 0, r = arr.size()-1;
    while(l <= r){
        int mid = (l+r)/2;
        if(arr[mid] == x) return mid;
        else if(arr[mid] < x) l = mid + 1;
        else r = mid - 1;
    }
    return -1;
}

int main(){
    std::vector<int> arr{1, 2, 3, 4, 5};
    int pos = binarySearch(arr, 4);
    std::cout << pos << std::endl;
    return 0;
}
```

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		
评论 1

	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值