[Programación] algoritmo y el algoritmo codicioso

algoritmo Greedy base teórica

Definición:
En el proceso de búsqueda de la solución óptima, la base de algún tipo de normas codiciosos, a partir del estado inicial del problema, vaya directamente a la solución óptima para cada paso, por codiciosos de selección varias veces, toda la cuestión de los resultados finales óptimos solución, este método de solución es un algoritmo codicioso.
No codicioso algoritmo para examinar la cuestión en su conjunto, elige para que sea la solución óptima en el sentido de algo local, pero sus características determinan el problema por el uso del título algoritmo voraz puede obtener la solución óptima.
Si un problema puede resolverse de varias maneras, al mismo tiempo, algoritmo voraz debe ser uno de la mejor opción.

Justificación:
algoritmo voraz es una opción en cada paso están tomando la mejor o la mejor opción en su estado actual, con la esperanza de obtener el mejor resultado o el mejor algoritmo.
algoritmo voraz es un enfoque jerárquico puede ser la solución óptima bajo un cierto grado de importancia, la solución de un problema de conseguir a través de una serie de opciones, y cada opción que tenía algún sentido en absoluto del estado más actual buena opción. Esa solución óptima esperanza a todo el problema de la solución óptima obtenida por los problemas locales.
Esta estrategia es un método muy simple, muchos problemas pueden solución mejor en general, pero no puede garantizar siempre eficaz, ya que no es capaz de obtener la mejor solución global a todos los problemas.
estrategia codiciosa de resolución de problemas, tenemos que resolver dos problemas:
(1) El título es apropiado para resolver la estrategia codiciosa;
(2) ¿Cómo elegir los estándares codiciosos con el fin de obtener la mejor solución mejor / del problema.

La diferencia entre la Programación Dinámica:
la propiedad elección codiciosos se refiere a hacer preguntas a la solución global óptima puede ser la mejor elección a través de una serie de local, a saber codiciosos optar por lograr.
Este es un algoritmo factible primer elemento esencial codiciosos, la principal diferencia es el algoritmo voraz y el algoritmo de programación dinámica.
(1) En el algoritmo de programación dinámica, la elección hecha cada paso es a menudo depende de la solución a los problemas relacionados con los niños, por lo que sólo después de resolver los problemas relacionados con los niños, con el fin de tomar una decisión.
(2) el algoritmo codicioso, sólo para hacer la mejor elección en el estado actual, es decir, la elección óptima local, entonces la solución sub-problema correspondiente producido después de la selección de nuevo.

  • Cuando la solución óptima contiene solución óptima a un problema de los problemas de su hijo, diciendo que este tema tiene estructural por debajo del óptimo.
    Usando la estrategia codicioso a cada conversión ha alcanzado solución óptima. la naturaleza subestructura óptima del problema es la característica clave de este problema puede ser codicioso algoritmo o algoritmo de programación dinámica es.
  • Greedy cada operación tiene un impacto directo en los resultados del algoritmo, y la programación dinámica no es.
    1. algoritmo voraz para cada sub-soluciones de problemas tiene que tomar una decisión, no se puede hacer retroceder; se seleccionará programación dinámica en base a los resultados actuales de la selección anterior, la función de back-off.
    2. La programación dinámica se utiliza principalmente en el problema de dos o tres dimensiones, pero la codicia es generalmente un problema unidimensional.

Greedy resolución de problemas algoritmo:
utilizar un algoritmo voraz para resolver el problema deben considerar los siguientes aspectos:
(1) el conjunto candidato A:
Con el fin de soluciones de construcción para los problemas, hay un problema como el conjunto de candidatos Una posible solución, que es la última solución del problema se toman de conjunto candidato a A.
(2) un conjunto de soluciones S:
como la elección codiciosos, el conjunto de soluciones S sigue expandiéndose hasta que la solución completa del problema de configuración se encuentran.
función (3) para resolver la solución:
Compruebe solución el conjunto solución completa S constituye el problema.
(4) Seleccione la función de selección:
Esa estrategia codiciosa, que es la clave para el método codicioso, que indica qué candidatos más quieren constituir una solución al problema, la función objetivo y función de selección suele estar relacionada.
(5) posibles funciones factible:
Comprobar añadió un conjunto de soluciones del candidato viable, después de que las soluciones satisface el juego de extensión limitaciones.

ejemplo típico

I. Arreglos ACTIVIDADES

[Problema]
n con un conjunto de eventos E = {1,2, ..., n }, donde cada actividad requiere el mismo recurso, tal como una sala de conferencias o similar, y un único evento puede utilizar este recurso al mismo tiempo .
I Cada actividad tiene un requisito de utilizar el recurso šī hora de inicio y un tiempo fi fin, y si <fi. Si se selecciona el evento i, los recursos que ocupa intervalo de tiempo entreabierta [si, fi) en el interior. Si el intervalo [si, fi) con el intervalo [sj, fj) son disjuntos, llamados actividad i y j son actividad compatible. Cuando si ≥ fj o sj ≥ fi, actividades j compatible con el i activo.
arreglos actividades se selecciona actividades compatibles subconjunto de las colecciones más grandes en las actividades indicadas en.
Aquí Insertar imagen Descripción

[Análisis]
todas las actividades de orden cronológico, de adelante hacia atrá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;
}

En segundo lugar, el problema de la mochila
[Problema]
Dado un peso muerto mochila de M, teniendo en cuenta los elementos N, en el que el i-ésimo peso del artículo, el valor de wi (1≤i≤n), el artículo lleno requiere la mochila, y así la mochila el valor máximo de elementos dentro.
Hay dos tipos de mochila problema (dependiendo de si los artículos se pueden separar), si el artículo no puede ser dividido, llamado el 0-1 problema de la mochila (programación dinámica); Si el artículo puede ser dividida, se llama problema de la mochila (un algoritmo voraz).
Aquí Insertar imagen Descripción
[Análisis]
Hay tres maneras de seleccionar artículos:
(1) como el problema 0-1 mochila, un algoritmo de programación dinámica para obtener el valor óptimo 220;
(2) como el problema 0-1 mochila, algoritmo voraz, de acuerdo con coste seleccionar elementos de un orden alto en el extremo para obtener el valor óptimo 160. Debido a los bienes indivisibles, y el espacio restante se desperdicia.
(3) como un problema de la mochila, algoritmo voraz, de acuerdo con el orden de los artículos de alto coste seleccionados al final obtener el valor óptimo de 240. Dado que el artículo se puede separar, el espacio restante de la porción cargada del artículo 3, para obtener un mejor rendimiento.

[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;
}
Publicados 335 artículos originales · ganado elogios 110 · Vistas a 20000 +

Supongo que te gusta

Origin blog.csdn.net/weixin_43460224/article/details/105245433
Recomendado
Clasificación