`
200830740306
  • 浏览: 109432 次
  • 性别: Icon_minigender_1
  • 来自: 广州
社区版块
存档分类
最新评论

poj1042 枚举+贪心算法

阅读更多
import java.io.BufferedInputStream;
import java.util.Arrays;
import java.util.Scanner;

/**
 * poj1042 枚举+贪心算法
 * @author NC
 */
public class Poj1042 {

    public static void main(String[] args) {
        Scanner scan = new Scanner(new BufferedInputStream(System.in));
        while (scan.hasNext()) {
            //输入
            int n = scan.nextInt();
            if (n == 0) {
                break;
            }
            int h = scan.nextInt();
            h = h * 12;//以5分钟为一个时间单位
            int[] fish = new int[n];
            int[] decrease = new int[n];
            int[] interval = new int[n];
            for (int i = 0; i < n; i++) {
                fish[i] = scan.nextInt();
            }
            for (int i = 0; i < n; i++) {
                decrease[i] = scan.nextInt();
            }
            interval[0] = 0;//interval[i]表示以第i个湖为终点时所花路程时间
            for (int i = 1; i < n; i++) {
                interval[i] = scan.nextInt() + interval[i - 1];
            }

            //先确定是以哪一个湖为终点,枚举求出最大的
            //以第一个湖为终点
            int[] maxResult = new int[n];
            int max = maxFish(h, Arrays.copyOf(fish, 1), decrease, maxResult);
            for (int i = 1; i < n; i++) {
                if (h <= interval[i]) {
                    break;//时间不够,无法再走远了
                }
                //以第i个湖为终点
                int[] result = new int[n];
                int m = maxFish(h - interval[i], Arrays.copyOf(fish, i + 1), decrease, result);
                if (m > max) {
                    max = m;
                    maxResult = Arrays.copyOf(result, result.length);
                }
            }
            //输出结果
            for (int i = 0; i < maxResult.length; i++) {
                if (i > 0) {
                    System.out.print(", ");
                }
                System.out.print(maxResult[i] * 5);
            }
            System.out.println("");
            System.out.println("Number of fish expected: " + max);
            System.out.println("");
        }
    }

    public static int maxFish(int time, int[] fish, int[] decrease, int[] result) {
        int maxNumber = 0;
        while (time > 0) {
            int max = fish[0];
            int maxIndex = 0;
            for (int i = 1; i < fish.length; i++) {
                if (fish[i] > max) {
                    max = fish[i];
                    maxIndex = i;
                }
            }
            fish[maxIndex] -= decrease[maxIndex];//鱼每一个时间单位相应减少
            if (fish[maxIndex] < 0) {
                fish[maxIndex] = 0;//湖里的鱼是没有负数的
            }
            result[maxIndex]++;
            maxNumber += max;
            time--;
        }
        return maxNumber;
    }
}

#include <stdio.h>
#include <memory.h>
//改成了c语言版的
void copy(int a[], int length, int b[]) {
    int i = 0;
    for (i = 0; i < length; i++) {
        b[i] = a[i];
    }
}

int maxFish(int end, int time, int fish[], int decrease[], int result[]) {
    int i, maxNumber = 0, max, maxIndex;
    while (time > 0) {
        max = fish[0];
        maxIndex = 0;
        for (i = 1; i < end; i++) {
            if (fish[i] > max) {
                max = fish[i];
                maxIndex = i;
            }
        }
        fish[maxIndex] -= decrease[maxIndex]; //鱼每一个时间单位相应减少
        if (fish[maxIndex] < 0) {
            fish[maxIndex] = 0; //湖里的鱼是没有负数的
        }
        result[maxIndex]++;
        maxNumber += max;
        time--;
    }
    return maxNumber;
}

int main() {
    int n, h, i;
    int fish[25] = {0}, decrease[25] = {0}, interval[25] = {0}, maxResult[25] = {0}, temp[25] = {0}, result[25] = {0};
    while (scanf("%d", &n) && n != 0) {
        memset(fish, 0, sizeof (fish));
        memset(decrease, 0, sizeof (decrease));
        memset(interval, 0, sizeof (interval));
        memset(maxResult, 0, sizeof (maxResult));
        memset(interval, 0, sizeof (interval));
        //输入
        scanf("%d", &h);
        h = h * 12; //以5分钟为一个时间单位
        for (i = 0; i < n; i++) {
            scanf("%d", &fish[i]);
        }
        for (i = 0; i < n; i++) {
            scanf("%d", &decrease[i]);
        }
        interval[0] = 0; //interval[i]表示以第i个湖为终点时所花路程时间
        for (i = 1; i < n; i++) {
            scanf("%d", &interval[i]);
            interval[i] += interval[i - 1];
        }
        //先确定是以哪一个湖为终点,枚举求出最大的
        //以第一个湖为终点
        copy(fish, 1, temp);
        int max = maxFish(1, h, temp, decrease, maxResult);
        for (int i = 1; i < n; i++) {
            if (h <= interval[i]) {
                break; //时间不够,无法再走远了
            }
            //以第i个湖为终点
            memset(result, 0, sizeof (result));
            copy(fish, i + 1, temp);
            int m = maxFish(i + 1, h - interval[i], temp, decrease, result);
            if (m > max) {
                max = m;
                memset(maxResult, 0, sizeof (maxResult));
                copy(result, i + 1, maxResult);
            }
        }
        //输出结果
        for (i = 0; i < n; i++) {
            if (i > 0) {
                printf(", ");
            }
            printf("%d", maxResult[i] * 5);
        }
        printf("\n");
        printf("Number of fish expected: %d", max);
        printf("\n");
        printf("\n");
    }
    return 1;
}

分享到:
评论

相关推荐

    POJ算法题目分类

    * 贪心:贪心算法是指通过选择当前最优的解来解决问题的方法,如 poj1328、poj2109、poj2586。 * 递归和分治法:递归和分治法是指将问题分解成多个小问题,通过解决小问题来解决大问题,如 poj3295。 * 递推:递推是...

    ACM 详解算法目录

    例如,POJ1753和POJ2965是枚举算法的经典例题,而POJ1328、POJ2109和POJ2586则是贪心算法的代表题。 图算法部分涵盖了图的深度优先遍历和广度优先遍历、最短路径算法、最小生成树算法、拓扑排序和二分图的最大匹配...

    poj算法题目实现.zip_algorithm_arrangement4hv_conditionyis_poj problems

    这可能需要用到贪心算法(Greedy Algorithm)或者深度优先生成树(Depth First Search Tree)来枚举所有可能的操作序列,找到满足条件的最少操作数。 以上五个题目涵盖了图论、动态规划、回溯法、数论和贪心算法等...

    ACM常用算法及其相应的练习题.docx

    * 贪心:poj1328, poj2109, poj2586 * 递归和分治法 * 递推 * 构造法:poj3295 * 模拟法:poj1068, poj2632, poj1573, poj2993, poj2996 二、图算法 * 图的深度优先遍历和广度优先遍历 * 最短路径算法:dijkstra, ...

    poj题目分类

    * 贪心算法:通过选择当前最优的解决方案来解决问题,例如 poj1328、poj2109、poj2586。 * 递归和分治法:通过将问题拆分成小问题来解决,例如 poj3295。 * 递推法:通过逐步解决问题来获得最终解,例如 poj1068...

    史上最全poj题目分类

    贪心算法是一种常用的算法思想,贪心算法的核心思想是每次选择当前情况下最优的选择,以达到全局最优的目的。例如,在01 背包问题中,采用贪心算法可以选择当前最优的选择,以达到最大化的效果。 递归算法是一种...

    ACMer需要掌握的算法讲解 (2).docx

    * 贪心算法:POJ1328、POJ2109、POJ2586 * 递归和分治法 * 递推算法 * 构造法:POJ3295、POJ3259、POJ1062、POJ2253、POJ1125、POJ2240 * 最小生成树算法:prim、kruskal、POJ1789、POJ2485、POJ1258、POJ3026 * ...

    poj各种分类

    贪心算法是一种局部最优解策略,每次选择当前状态下看似最优的选择,以期望最终达到全局最优解。例如,poj1328和poj2109就是典型的贪心问题。贪心算法的关键在于正确性证明,确保每一步的局部最优能够导向全局最优。...

    poj训练计划.doc

    - 贪心算法:在每一步选择中都采取在当前状态下最好或最优的选择,如`poj1328, poj2109, poj2586`。 - 分治法:将一个复杂的问题分成两个或更多的相同或相似的子问题,直到最后子问题可以简单的直接求解,如`poj...

    acm poj300题分层训练

    如poj1753、poj2965用于枚举训练,poj1328、poj2109、poj2586是贪心策略的实例,poj2506和poj3295涉及分治法,poj1068、poj2632等则用于模拟训练。 2. **图算法**:包括图的深度优先遍历、广度优先遍历、最短路径...

    很快速的提高算法能力.pdf

    贪心算法则是每次选择当前最优解,以期望全局最优,如 poj1328 和 poj2109。递归和分治法是处理复杂问题的有效工具,例如 poj2586。递推和构造法也是常用技巧,poj3295 就是一个利用构造法的实例。模拟法则用于按照...

    ACM常用算法及其相应的练习题 (2).pdf

    * 贪心算法:贪心算法是指在每一步选择当前最优解,以期获得最优的总体解。例题:poj1328、poj2109、poj2586。 * 递归和分治法:递归和分治法是指将问题分解成更小的子问题,递归地解决这些子问题,然后将结果组合...

    ACM常用算法及其相应的练习题 (2).docx

    本部分涵盖了基本算法,包括枚举、贪心、递归和分治法、递推、构造法和模拟法。这些算法是程序员和算法爱好者必须掌握的基本技能。 (1) 枚举:poj1753, poj2965 (2) 贪心:poj1328, poj2109, poj2586 (3) 递归和...

    POJ题目简单分类(ACM)

    - **贪心**:每次选择当前最优解,如poj1328、poj2109和poj2586。 - **递归与分治**:将大问题分解为小问题解决,如快速排序、归并排序等。 - **递推**:用递推公式解决复杂问题,如斐波那契数列。 - **构造法**...

    ACM 比赛 POJ的训练计划,,,非常不错,关键在于坚持

    在初期阶段,选手需要掌握基本算法,如枚举、贪心、递归和分治法等。然后,需要学习图算法,如深度优先遍历、广度优先遍历、最短路径算法和最小生成树算法等。最后,需要学习数据结构,如串、排序、堆和哈希表等。 ...

    强大的POJ分类——各类编程简单题及其算法分类

    1. **枚举**:通过尝试所有可能的情况来解决问题,如POJ题目1753和2965。 2. **贪心**:采取局部最优策略,每次选择当前看来最好的决策,如POJ题目1328、2109和2586。 3. **递归和分治法**:将大问题分解为小问题,...

    【最新+免费】ACM主要算法.doc

    1. 枚举:通过穷举所有可能的解决方案来解决问题,例如POJ 1753和POJ 2965题目。 2. 贪心:局部最优策略,每次选择当前最优解,如POJ 1328和POJ 2109。 3. 递归与分治:将问题分解为小问题,再合并答案,例如POJ ...

    ACMer需要掌握的算法讲解.docx

    2. 贪心算法(poj1328, poj2109, poj2586) 3. 递归和分治法 4. 递推法 5. 构造法(poj3295, poj3259, poj1062, poj2253, poj1125, poj2240) 6. 最小生成树算法(prim, kruskal)(poj1789, poj2485, poj1258, poj...

    算法训练方案详解

    - **定义**: 贪心算法是根据某种策略做出局部最优选择,以期达到全局最优。 - **应用场景**: 当可以证明每一步的局部最优选择最终会导致全局最优解时适用。 - **示例题目**: POJ 1328, POJ 2109, POJ 2586 - **...

    ACM算法总结大全——超有用!

    2. 贪心:贪心算法在每一步选择局部最优解,期望整体得到全局最优,如poj1328、poj2109和poj2586。 3. 递归与分治法:递归是函数调用自身的过程,而分治法将大问题分解为小问题求解,如poj3295中的应用。 4. 递推:...

Global site tag (gtag.js) - Google Analytics