精华内容
下载资源
问答
  • 近似算法 集合覆盖问题代码实现 基于贪心策略 基于线性规划策略
    千次阅读 热门讨论
    2017-05-31 10:46:05

    一、  实验目的

    1.      掌握近似算法的基本思想与方法

    2.      掌握集合覆盖问题近似算法的设计思想和方法

    3.      熟练使用高级编程语言实现近似算法

    4.      利用实验测试给出不同近似算法的性能以理解其优缺点。

    二、  实验内容

    1.集合覆盖问题:

    输入:有限集X,X的自己合族F,X=US∈FS

    输出:C包含于F,满足

    (1)       X=US∈FS

    (2)       C是满足条件(1)的最小集族,即|C|最小

    2.实现方式:matlab

    三、实验过程及结果

    抱歉,后面的部分确实上传不上去,下面附上github代码地址

    https://github.com/hengliwang/-

    更多相关内容
  • 以优化形式描述的集合覆盖问题是一个NP难问题,设计快速有效的近似算法,具有重要的理论与现实意义。基于贪心算法思想,提出了一种求解带权集合覆盖问题近似算法,并讨论了该算法的相对近似比。
  • 集合覆盖问题近似计算

    千次阅读 2019-06-07 10:26:22
    算法作业第三题,集合覆盖问题近似计算 例题: Sample Input 1 2 3 4 5 4 1 2 3 2 4 3 4 4 5 Sample Output 2 1 4 只测试了样例一组,可能会存在问题,请谨慎参考 import java.util.*; public ...

    算法作业第三题,集合覆盖问题近似计算

    例题:

     

    Sample Input

    1 2 3 4 5

    4

    1 2 3

    2 4

    3 4

    4 5

     

    Sample Output

    2

    1 4

    只测试了样例一组,可能会存在问题,请谨慎参考

    import java.util.*;
    public class Main {
    	public static ArrayList<Integer> Uaggregate = new ArrayList<Integer>();			//存放全集
    	public static ArrayList<Integer> tmpAggregate = new ArrayList<Integer>();		//存放临时的集合
    	public static ArrayList<Integer> tmpAgNum = new ArrayList<Integer>();			//存放临时的集合是由哪几个子集组成的
    	public static ArrayList<Integer> BestAgNum = new ArrayList<Integer>();			//存放临时的集合是由哪几个子集组成的
    	public static int num;
    	public static void main(String[] args) {
    		Scanner sc = new Scanner(System.in);
    		String Str = sc.nextLine();
    		String[] str = Str.split(" ");
    		for(int i=0;i<str.length;i++) {
    			Uaggregate.add(Integer.parseInt(str[i]));			//给全集赋值
    		}
    		int m = sc.nextInt();
    		sc.nextLine();
    		num = m;
    		ArrayList<Integer> subset[] = new ArrayList[m]; 
    		for(int i=0;i<m;i++) {
    			Str = sc.nextLine();
    			str = Str.split(" ");
    			subset[i] = new ArrayList<Integer>();
    			for(int j=0;j<str.length;j++) {
    				subset[i].add(Integer.parseInt(str[j]));		//子集赋值
    			}
    		}
    		Recursion(subset, 0, m);						//递归遍历全部可能
    		System.out.println(num);
    		//转化成标准输出格式
    		int[] bestAgNum = new int[BestAgNum.size()];				//存放最终最优结果的数组
    		for(int i=0;i<BestAgNum.size();i++) {
    			System.out.print((BestAgNum.get(i)+1)+" ");
    		}
    	}
    	static void Recursion(ArrayList<Integer> subset[], int i, int m) {
    		if(i<m-1)								//不加当前集合
    			Recursion(subset, i+1, m);
    		ArrayList<Integer> tmp = new ArrayList<Integer>();
    		tmp = (ArrayList<Integer>) tmpAggregate.clone();
    		tmpAggregate.removeAll(subset[i]);					   //加当前集合
    		tmpAggregate.addAll(subset[i]);
    		tmpAgNum.add(i);
    		if(tmpAggregate.size()==Uaggregate.size() && tmpAgNum.size()<num) {
    			BestAgNum = (ArrayList<Integer>) tmpAgNum.clone();
    			num = tmpAgNum.size();
    		}
    		else if(tmpAgNum.size()<num && i<m-1){
    			Recursion(subset, i+1, m);
    		}
    		tmpAggregate = (ArrayList<Integer>) tmp.clone();			//加当前集合情况下退栈
    		tmpAgNum.remove(tmpAgNum.size()-1);
    	}
    }
    

     

    展开全文
  • 假设你办了个广播节目,要让全美50个洲的听众都能听到,为此,你需要决定在哪些广播台播出,在每个广播台播出都需要支付费用,力图以最少的费用达到覆盖的目的——来自算法图解 贪婪思路:1:找出所有广播台中...

    问题描述:

    假设你办了个广播节目,要让全美50个洲的听众都能听到,为此,你需要决定在哪些广播台播出,在每个广播台播出都需要支付费用,力图以最少的费用达到覆盖的目的——来自算法图解

     贪婪思路:1:找出所有广播台中覆盖面积最广的(面积指的是未覆盖的面积) 换言之就是寻找覆盖未覆盖面积最广的广播站

    2:记录本轮的覆盖区域 更新未覆盖区域(取交集 用到集合set)

    3:重复 1 2 直至完全覆盖

     初始信息:state_needed(需要覆盖的州),stations 字典(每个广播台覆盖的州)fianl_stations(保存最终选择的广播台)

    state_needed=set(['mt','wa','or','id','nv','ut','ca','az'])
    stations={}
    stations['1']=set(['id','nv','ut'])
    stations['2']=set(['wa','id','mt'])
    stations['3']=set(['or','nv','ca'])
    stations['4']=set(['nv','ut'])
    stations['5']=set(['ca','az'])
    final_stations=set()
    def find_covermost():
        ans,res=0,''
        for k,v in stations.items():
            if ans<len(v&state_needed) and k not in final_stations:ans,res=len(v),k#v&state_needed很关键,覆盖面积广指的是覆盖还没覆盖的面积最广
        final_stations.update([res])
        return stations[res]
    while state_needed:
        state_needed-=find_covermost()
    print(final_stations)
    print(state_needed)
    ##输出{'5', '3', '1', '2'}
    #set()
    

    总结:贪婪算法是一种近似算法,通过寻找局部最优解获得全局最优解 

    前面学到的BFS与狄克斯特拉算法就包含的贪婪的思想

    另外今天学到了集合中的两个操作 并集>>&    添加元素>>set.update([seq])

    我是小郑 期待和你一起进步

    展开全文
  • 整个贪心算法解决集合覆盖问题的实现代码如下。 # 集合覆盖问题-part1-贪心算法 import time import random from itertools import chain import matplotlib.pyplot as plt # 生成有限集X X = set() iter_ = [100,...

    写这篇主要是想与线性规划求解集合覆盖问题做个性能对比,基于后者的实现方法可参考博文

    本文中数据集X及集族生成规则同上一篇,这里不再介绍。整个贪心算法解决集合覆盖问题的实现代码如下。

    # 集合覆盖问题-part1-贪心算法
    import time
    import random
    from itertools import chain
    import matplotlib.pyplot as plt
    
    # 生成有限集X
    X = set()
    iter_ = [100,200, 500]
    time_cost = []
    for n in iter_:
        start_t = time.clock()
        X = random.sample(range(1, 10000), n)
        print('集合X中元素个数:', len(X))
        print('集合X:', X)
    
        # 生成子集
        S0 = random.sample(X, 20)
        n1 = random.randint(1, 20)
        x1 = random.randint(1, n1)
    
        S1 = (random.sample(set(S0), x1))+(random.sample(set(X)-set(S0), n1-x1))
        Sub_set = [S0, S1]
    
        for item in range(2, n):
            S_item_len = random.randint(1, 20)
            S_last_len = random.randint(1, S_item_len)
    
            Sub_set_item = list(chain.from_iterable(Sub_set))  # 压平嵌套列表
    
            if len(set(X) - set(Sub_set_item)) >= S_item_len-S_last_len:
                S_now = (random.sample(set(Sub_set_item), S_last_len))+(random.sample(set(X)-set(Sub_set_item), S_item_len-S_last_len))
                Sub_set.append(S_now)
            else:
                Sub_set.append(list(set(X)-set(Sub_set_item)))
                break
        # print(set(X)-set(list(chain.from_iterable(Sub_set))))  # 检查集合中的元素是否已被子集族全覆盖
    
        for j in range(n-len(Sub_set)):
            select_num = random.randint(1, 20)
            select_sub = random.sample(X, select_num)
            Sub_set.append(select_sub)
        print('子集族:', Sub_set)
    
        # 定义函数返回当前子集族中元素个数最多的子集索引
        def max_len_list(sub_list):
            len_sub_list = []
            for i in range(len(sub_list)):
                len_sub_list.append(len(sub_list[i]))
            len_max_list = max(len_sub_list)
            return len_sub_list.index(len_max_list)
    
        # 贪心算法
        final_set = []
        while len(set(X)) > len(set(list(chain.from_iterable(final_set)))):
            # 返回当前子集族中元素最多的子集,将其加到可行解中
            max_index = max_len_list(Sub_set)
            final_set.append(Sub_set[max_index])
    
            # 从当前子集族中删掉被加到可行解中的子集
            del Sub_set[max_index]
    
        print('可行解:', final_set)
    
        # 记录运行时间
        end_t = time.clock()
        time_iter = end_t-start_t
        print("集合覆盖问题-基于贪心思想运行时间", time_iter)
        time_cost.append(time_iter)
        print('\n')
    
    # 可视化
    plt.plot(iter_, time_cost)
    plt.show()
    

    程序运行结果如下图
    在这里插入图片描述
    可以看出与线性规划求解该问题相比,基于贪心策略的近似算法在性能上有明显提高。

    展开全文
  • 贪心算法集合覆盖问题

    千次阅读 2021-02-01 18:53:40
    一、贪心算法概述 贪心算法的核心思想可以总结为:贪心算法总是作出在当前看来最好的选择。 也就是说贪心算法并不从整体最优...二、集合覆盖问题 2.1 问题描述 假设你办了个广播节目,要让国内的 8 个重要城市的听
  • 《顶点覆盖问题的NP完全证明和近似算法求解》由会员分享,可在线阅读,更多相关《顶点覆盖问题的NP完全证明和近似算法求解(5页珍藏版)》请在人人文库网上搜索。1、顶点覆盖问题的NP完全证明和顶点覆盖优化问题近似...
  • 贪婪算法近似集合覆盖问题的解

    万次阅读 2017-08-28 21:43:59
    其中每个广播台覆盖特定的区域,不同广播台的覆盖区域可能重叠这样的话要遍历所有的可能的子集合组合,就有2n2^n,其中n为广播台数目,用大O表示法运行时间为O(2n)O(2^n)。如果广播台很多,就成了一个NP难问题,而...
  • 集合覆盖近似算法PPT学习教案.pptx
  • 1.贪心算法(又称贪婪算法)是指,在对问题求解时,总是做出在当前看来是最好的选择。也就是说,不从整体最优上加以考虑,算法得到的是在某种意义上的局部最优解 2.贪心算法不是对所有问题都能得到整体最优解,关键...
  • 贪心算法1、贪心算法的介绍2、贪心算法解决集合覆盖问题实现 1、贪心算法的介绍 应用场景:集合覆盖问题 贪心算法的介绍: 1)贪婪算法(贪心算法)是指在对问题进行求解时,在每一步选择中都采取最好或最优的选择...
  • 贪心算法 贪心算法:在对问题求解时,总是做出在当前看来是最好的选择 是由局部到整体,算法得到的是在某种意义上的局部最优解,对整体是近似最优解 ...集合覆盖问题 一个广播覆盖问题: 存在以下广播,
  • 贪心算法最佳应用-集合覆盖 假设存在如下表的需要付费的广播台,以及广播台信号可以覆盖的地区。如何选择最少的广播台,让所有 的地区都可以接收到信号 思路分析:  如何找出覆盖所有地区的广播台的集合呢,使用...
  • 集合覆盖问题(贪婪算法+分层)

    千次阅读 2020-10-31 11:38:54
    问题描述: ...关于该算法相关的引理和定理如下,具体证明参考近似算法P14-15页: (2)分层 下面我将举个图的实例来具体解释一下上图的思想: 假设一开始的图G0为 清除孤立点,将他们添加到集合Di
  • 贪心算法实践之集合覆盖问题

    千次阅读 2021-04-22 09:34:13
    介绍贪婪算法(贪心算法)是指在对问题进行求解...应用场景-集合覆盖问题假设存在下面需要付费的广播台,以及广播台信号可以覆盖的地区。 如何选择最少的广播台,让所有的地区都可以接收到信号image思路分析:如何找出...
  • 集合覆盖问题——贪婪算法

    千次阅读 2018-10-10 17:27:39
    1、问题抛出 快速选用最少的广播台覆盖需要的地市 states_needed = set(['mt','wa', 'or', 'id', 'nv', 'ut', 'ca', 'az']) stations = {} stations['kone'] = set(['id', 'nv', 'ut']) stations['ktwo'] = set(['id...
  • 贪婪算法所得到的结果不一定是最优的结果(有时候会是最优解),但是都是相对近似(接近)最优解的结果 题目: 假设存在下面需要付费的广播台,以及广播台信号可以覆盖的地区。如何选择最少的广播台,让所有的地区 都...
  • 求解集合覆盖问题 子集生成算法 贪心近似求解 算法Greedy_cover(X, F) 输入 : 有限集X, X的子集合族F, X=∪S∈F S,|X|=|F| 输出 : C⊆F,满足X=∪S∈F S且C是满足X=∪S∈F S的最小集族,即|C|最小 1: U←X 2: C←...
  • (点击上方公众号,可快速关注)来源:伯乐在线 -五道口宅男潇涧链接:http://blog.jobbole.com/87009/顶点覆盖问题可以用几种不同的算法来实现,本篇文章使用的是分支限界法来实现,或许以后会介绍其他的实现算法,...
  • 贪心算法集合覆盖问题

    万次阅读 2019-09-30 09:32:10
    文章目录贪心算法教室调度问题背包问题集合覆盖问题NP完全问题总结 贪心算法 贪心算法是一种解决问题的思路:每一步选择局部最优解,最终也许不会得到最优结果,但是也会接近最优结果。 贪心算法具有以下特点: 每...
  • Set Cover problem是计算机算法复杂度领域的经典问题问题如下定义:首先有一个元素集合U,给定一系列集合,各集合之中含可能有一些共同的元素(如图所示)。要求访问最少的集合,可以得到U中所有的元素,求出满足...
  • 集合覆盖问题在网络设计领域中...建立了集合覆盖问题的0-1规划模型,给出了源于贪心思想的近似算法,并从原始-对偶规划的角度进行了证明,基于LINGO软件的传感器网络最优设计案例验证了模型的正确性和算法的有效性。
  • 最小集合覆盖

    2013-01-14 12:14:48
    与一般的求最小集合覆盖不同,目前网上的都是抄来抄去讲贪婪算法等近似算法,这里给出来求最小集合覆盖的精确算法,并实现了MPI并行化,速度极快
  • 组合优化问题近似算法问题规模为n,近似率ρ(n)满足:max(CC∗,C∗C)≤ρ(n)当问题规模为n,近似率\rho(n)满足:max(\frac{C}{C^*},\frac{C^* }{C})\leq \rho(n)当问题规模为n,近似率ρ(n)满足:max(C∗C​,CC∗...
  • 1、掌握近似算法的基本设计思想与方法, 2、掌握集合覆盖问题近似算法的设计思想与方法, 3、熟练使用高级编程语言实现近似算法, 4、利用实验测试给出不同近似算法的性能以理解其优缺点 集合覆盖问题python求解
  • 假如你办了个广播节目,要让所有的州的听众都能听到。在每个广播台播出都需要收费,因此你要保证尽可能少的广播可以播出,每个广播台都覆盖特定区域,不同...如何找出覆盖所有州的广播台集合呢?我们可以采用贪婪算法
  • 贪婪算法(贪心算法)是指在对问题进行求解时,在每一步选择中都采取最好或者最优(即最有利)的选择,从而希望能够导致结果是最好或者最优的算法 贪婪算法所得到的结果不一定是最优的结果(有时候会是最优解),...
  • 贪心算法集合覆盖问题 1.贪心算法介绍 贪婪算法(贪心算法)是指在对问题进行求解时,在每一步选择中都采取最好或 者最优(即最有利)的选择,从而希望能够导致结果是最好或者最优的算法 贪婪算法所得到的结果不一定...
  • num=[]; z=zeros(353,546); N=sum(sum(s{54}==1)); U=s{54};...%存储选择的集合编号 s0{t}=z; if Q==s{54}%Q已经等于全集 故停止循环 break; end end https://pan.baidu.com/s/1jJwSGDK(包含元组s)
  • 1)贪心算法是指再对问题进行求解时,在每一步选择中都采取最好或者最优(即最有利)的选择,从而希望能够导致结果时最好或者最优的算法 2)贪心算法所得到的结果不一定是最优的结果(有时会是最优解),但都是相对...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,300
精华内容 4,520
关键字:

集合覆盖问题近似算法

友情链接: VISCO1D-v3.zip