[Programação] algoritmo e algoritmo guloso

algoritmo guloso base teórica

Definição:
No processo de procurar a solução ideal, a base para algum tipo de normas gananciosos, a partir do estado inicial do problema, vá diretamente para a solução ideal para cada etapa, pela seleção várias vezes gananciosos, toda a questão dos resultados finais óptimos solução, este método de solução é um algoritmo mais.
Não algoritmo guloso para analisar a questão como um todo, decidir torná-la a melhor solução no sentido de apenas local, mas as suas características determinam o problema com o uso do algoritmo guloso título pode obter a solução ideal.
Se um problema pode ser resolvido de várias maneiras, ao mesmo tempo, algoritmo guloso deve ser um dos a melhor escolha.

Justificativa:
algoritmo guloso é uma escolha em cada passo a tomar a melhor ou a melhor escolha em seu estado atual, na esperança de obter o melhor resultado ou o melhor algoritmo.
algoritmo guloso é uma abordagem hierárquica pode ser a solução ideal sob alguma medida de significado, resolvendo um problema para obter através de uma série de escolhas, e cada escolha que fez algum sentido em todo o estado mais atual boa escolha. Essa solução esperança ideal para todo o problema da solução ótima obtida por questões locais.
Esta estratégia é um método muito simples, muitos problemas podem solução melhor no geral, mas não pode garantir sempre eficaz, porque não é capaz de obter a melhor solução global para todos os problemas.
Estratégia gulosa de resolução de problemas, é preciso resolver dois problemas:
(1) O título é adequado para resolver a estratégia gulosa;
(2) como para escolher os padrões gananciosos, a fim de obter a melhor solução melhor / do problema.

A diferença entre Programação Dinâmica:
propriedade escolha gananciosos refere-se a fazer perguntas a solução global ótima pode ser a melhor escolha através de uma série de local, ou seja ganancioso optar por alcançar.
Este é um algoritmo viável primeiro elemento essencial ganancioso, a principal diferença é o algoritmo ganancioso e algoritmo de programação dinâmica.
(1) No algoritmo de programação dinâmica, a escolha feita cada etapa é muitas vezes dependente da solução para os problemas relacionados com a criança, de modo que só depois de resolver problemas relacionados com a criança, a fim de fazer uma escolha.
(2) o algoritmo mais, só para fazer a melhor escolha, no estado actual, isto é, a escolha óptima local, em seguida, a solução de sub-problema correspondente produzido após a selecção de novo.

• Quando a solução ideal contém solução ideal para um problema de problemas de seu filho, dizendo que esta questão tem sub-óptima estrutural.
  Usando a estratégia ávido em cada conversão atingiu solução óptima. Optimal natureza subestrutura do problema é o elemento-chave deste problema pode ser ganancioso algoritmo ou algoritmo de programação dinâmica é.
• Greedy cada operação tem um impacto direto sobre os resultados do algoritmo, e programação dinâmica não é.
  1. algoritmo guloso para cada soluções sub-problema tem que fazer uma escolha, você não pode reverter; programação dinâmica serão selecionados com base nos resultados atuais da seleção anterior, função de back-off.
  2. A programação dinâmica é usada principalmente no problema de dois ou três dimensões, mas a ganância é geralmente problema unidimensional.

Greedy resolução de problemas algoritmo:
usar um algoritmo guloso para resolver o problema deve considerar os seguintes aspectos:
(1) o conjunto candidato A:
A fim de soluções de construir problemas, há um problema como o conjunto candidato Uma possível solução, que é a solução definitiva do problema são tomadas a partir conjunto candidato para A.
(2) um conjunto de soluções S:
Conforme a escolha ávido, o conjunto de soluções S continua a expandir-se até que a solução completa do problema a configuração se encontram.
função (3) para resolver a solução:
Verifique a solução de conjunto completo S solução constitui o problema.
(4) Selecione a função de selecionar:
Essa estratégia ganancioso, que é a chave para o método guloso, indicando quais os candidatos mais quer constituir uma solução para o problema, a função objetivo e função de seleção é geralmente relacionado.
(5) possíveis funções viável:
Verificar adicionou-se uma solução de conjunto candidato viável, após o que as soluções satisfaz o conjunto de extensão constrangimentos.

exemplo típico

I. arranjos ATIVIDADES

[Problema]
n com um conjunto de eventos E = {1,2, ..., n }, onde cada atividade exigem o mesmo recurso, como uma sala de aula ou similar, e apenas um evento pode usar este recurso, ao mesmo tempo .
I Cada atividade tem um requisito para usar o recurso Si hora de início e fim do tempo fi, e si <fi. Se o evento i é selecionado, os recursos que ocupa intervalo de tempo semi-aberto [si, fi) no interior. Se o intervalo [Si, fi) com o intervalo [sj, fj) são disjuntos, chamado de atividade i e j são compatíveis actividade. Quando si ≥ fj ou sj ≥ fi, actividades j a compatível com o i activo.
arranjos atividades é selecionado atividades subconjunto compatível dos maiores acervos nas atividades dadas.

[Análise]
todas as atividades de ordem cronológica, da frente para trás para tomar.

[Código]

#include<bits/stdc++.h>
using namespace std;
struct node
{
    int s;			//起始时间
	int f;			//结束时间
	int index;		//活动的编号
}a[100010];

int n;
int ss,ee;
int cmp(node a,node b)
{
    if(a.s!=b.s)
        return a.s<b.s;
    else
        return a.f<b.f;
}
vector<int>v;

int main()
{
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        cin>>a[i].s>>a[i].f;
        a[i].index=i;
    }
    sort(a+1,a+1+n,cmp);
    int tmp=1;
    v.push_back(a[1].index);
    for(int i=2;i<=n;i++)
    {
        if(a[i].s>=a[tmp].f)
        {
            v.push_back(a[i].index);
            tmp=i;
        }
    }
    for(int i=0;i<v.size();i++)
        cout<<v[i]<<" ";
    cout<<endl;
    return 0;
}

Em segundo lugar, o problema da mochila
[Problema]
Dado um peso morto mochila de H, considerando os itens n, em que o i-ésimo peso do produto, o valor de wi (1≤i≤n), artigo cheio exige a mochila, e de modo a mochila o valor máximo de itens dentro.
Existem dois tipos de mochila problema (dependendo se os itens podem ser separados), se o item não pode ser dividido, chamado o 0-1 problema da mochila (programação dinâmica); Se o item pode ser dividida, ele é chamado de problema da mochila (um algoritmo ganancioso).

[Análise]
Existem três maneiras de seleccionar itens:
(1) como o problema 0-1 mochila, um algoritmo de programação dinâmica para obter o valor ideal 220;
(2) como o problema 0-1 mochila, o algoritmo ávida, de acordo com o custo seleccionar itens de uma ordem elevada no final para obter o valor ideal de 160. Por causa de bens indivisíveis, eo espaço restante é desperdiçado.
(3) como um problema da mochila, o algoritmo ávida, de acordo com o fim a partir dos itens de alto custo seleccionados no final obter o valor ideal de 240. Uma vez que o artigo pode ser separado, o espaço restante da porção carregada do artigo 3, para obter um melhor desempenho.

[Código]

#include<bits/stdc++.h>
using namespace std;
struct node
{
    double value,weight,tmp;
    int index;
} a[100010];

int n;
double sum;
double ww;
int cmp(node a,node b)
{
    return a.tmp>b.tmp;
}

vector<int>v;

int main()
{
    cin>>n;
    cin>>ww;
    for(int i=1; i<=n; i++)
    {
        cin>>a[i].value>>a[i].weight;
        a[i].tmp=a[i].value/a[i].weight;
        a[i].index=i;
    }
    sort(a+1,a+1+n,cmp);
    double x=0;
    int cnt=1;
    for(int i=1; i<=n; i++)
    {
        if(x<ww)
        {
            x+=a[i].weight;
            sum+=a[i].value;
            v.push_back(a[i].index);
            cnt=i;
        }
    }
    if(x>ww)
        sum-=(x-ww)/a[cnt].weight*a[cnt].value;
    cout<<sum<<endl;
    return 0;
}