6

首先,我想坦白地说,以下问题是针对学校的,所以不要对我太苛刻:)

我在使用递归算法(这是一个要求)对 matlab 中的优化问题进行建模时遇到了一些问题。

问题的定义是:

考虑到 10 年的时间窗口,决定每年捕获的鱼量,知道目前湖中有 10000 条鱼,第 1 年,鱼的增长率是每年年初湖中存在的鱼的数量 + 20%。

设 x 为要捕获的鱼的数量,每条鱼的价格为 5 美元,捕鱼的成本为:

0.4x + 100 if x is <= 5000; 
0.3x + 5000 if  5000 <= x <= 10000; 
0.2x + 10000 if x > 10000; 

决定每年捕捞的鱼的数量,为期 10 年,以实现利润最大化。

未来收益每年折旧 0.2 倍,这意味着第 1 年赚取 1 美元与第 2 年赚取 0.8 美元相同,依此类推。

我目前已经定义了以下目标函数:

x -> quantity of fish to catch
b-> quantity of fish availavable in the beginning of year i
c(x,b) -> cost of catching x fish with b fishes available

f_i(b) = max {(5x - c(x,b)) + 0.8 * f_i+1((b - x) * 1.2)}

我将如何在matlab中实现这个?

这是我到目前为止所拥有的:

主文件

clear;

global M Kdep Cost RecursiveProfit ValorF prop

Kdep=[10; 20; 30; 40; 50; 60; 70; 80; 90; 100]; %max nr of fish in the lake at the beginning of each year, 10 years, in thousands. Growth factor = 20%

M=1000;

%Cost and Profit of selling i fishes given that there are j at the beginning of the year
for i = 1:50
    for j = 1:11
        Cost(i,j) = 0.2 * i + 10;
        RecursiveProfit(i,j) = 5 * i - Cost(i, j);
    end
end


for i = 1:10
    for j = 1:10
        Cost(i,j) = 0.3 * i + 5;
        RecursiveProfit(i,j) = 5 * i - Cost(i, j);
    end
end

for i = 1:5
    for j = 1:5
        Cost(i,j) = 0.4 * i + 0.1;
        RecursiveProfit(i,j) = 5 * i - Cost(i, j);
    end
end

%prop = 1 : 10;

ValorF = -M * ones(10, 50);


for a = 1:5
    ValorF(10, a) = 5 * a - (0.4 * a + 1); %On Year 10, if there are <= a thousand fishes in the lake ...
    prop(10, a) = a;
end

for b = 6:10
    ValorF(10, b) = 5 * b - (0.3 * b + 5); %On Year 10, if there are 6 <= a <= 10  thousand fishes in the lake ...
    prop(10, b) = b;
end

for c = 10:41
    ValorF(10, c) = 5 * c - (0.2 * c + 10); 
    prop(10, c) = c;
end

MaxProfit = RecursiveProfit(1, 10)

k1 = prop(1,10)

kant=k1;

y = 6 - Cost(kant,10);

for q=2:10
    if(kant == 0)
    kant = kant + 1;
end
    kq=prop(q,y)
    kant=kq;
    y = y - Cost(kant,q);
end %for i

功能

function y=RecursiveProfit(j,x)
global M Kdep Cost Prof ValorF prop

y=ValorF(j,x);

if y~= -M
    return
end %if

auxMax=-M;
decision=0;

for k=1:Kdep(j)
    if Prof(k,j) <= x-k
        aux=Prof(k,j)+RecursiveProfit(j+1, (x - k));
            if auxMax < aux 
                auxMax=aux;
                decision=k;
            end %if aux
        else break
    end %if Cost   

end %for k

ValorF(j,x)=auxMax;
prop(j,x)=decision;
y=auxMax;

这仅适用于年份为 10 且 b = 10(以千为单位的值)的情况。这与书中描述的“折扣利润问题”相同的问题

您能给我的任何帮助将不胜感激。

编辑1:我真的被困在这里了。如果你能帮我用Java实现这个,我会尝试将它移植到Matlab。

编辑 2:我将代码编辑为最​​新版本。现在我得到

“达到最大递归限制 500。”

你能帮助我吗?

编辑 3:我设法让它工作,但它只返回 0。

编辑 4:代码更新。现在我得到

试图访问 prop(2,0);index 必须是正整数或逻辑整数。

Main 中的错误(第 66 行)kq=prop(q,y)

4

2 回答 2

1
function gofishing(numoffishes,years)

growFactor=1.2;
%index shift, index 1 : 0 fishes
earn{1}=-inf(numoffishes+1,1);
%index shift, index 1 : 0 fishes
earn{1}(numoffishes+1)=0;
%previous: backpointer to find path of solution.
previous{1}=nan;

%index shift, index 1 : 0 fishes
vcosts = zeros(1,ceil(numoffishes*growFactor^years));

for idx=1:numel(vcosts)
    vcosts(idx)=costs(idx-1);
end

for step = 1:years*2
    fprintf('step %d\n',step);
    if mod(step,2)==1;
        %do fish grow step
        earn{step+1}=-inf(floor(numel(earn{step})*1.2)-1,1);
        previous{step+1}=nan(floor(numel(earn{step})*1.2)-1,1);
        for fishes=0:numel(earn{step})-1
            grownfishes=floor(fishes*1.2);
            earn{step+1}(grownfishes+1)=earn{step}(fishes+1);
            previous{step+1}(grownfishes+1)=fishes;
        end
    else
        %do fishing step
        earn{step+1}=-inf(size(earn{step}));
        previous{step+1}=nan(size(earn{step}));
        for fishes=0:numel(earn{step})-1
            if isinf(earn{step}(fishes+1))
                %earn is -inf, nothing to do
                continue;
            end
            possibleToFish=fishes:-1:0;
            %calculate earn for possible amounts to fish
            options=((vrevenue(possibleToFish)-vcosts(possibleToFish+1))*0.8^(step/2-1)+earn{step}(fishes+1))';
            %append -inf for not existing options
            options=[options;-Inf(numel(earn{step+1})-numel(options),1)];
            %found better option:
            better=earn{step+1}<options;
            earn{step+1}(better)=options(better);
            previous{step+1}(better)=fishes;
        end
    end
end
[~,fc]=max(earn{end});
fc=fc-1;
fprintf('ending with %d fishes and a earn of %d\n',fc,earn{end}(fc+1));
for step=(years*2):-1:2
    fc=previous{step}(fc+1);
    fprintf('fish count %d\n',fc');
end
end

function c=costs(x)
if (x<=5000)
    c=0.4*x + 100;
    return
end
if (x <= 10000)
    c=0.3*x + 5000;
    return
end
c=0.2*x + 10000;
return
end
function c=vrevenue(x)
c=5.*x;
end

再次阅读我的解决方案后,我有一些提高性能的想法:

  • 与其用向量(possibleToFish)索引 vcosts,不如直接使用 fishes 来索引。
  • 一步预分配选项/箱子

对于 10000,它在可接受的时间内运行(大约 5 分钟),对于更大的数据,我建议更新。

于 2013-11-08T01:50:22.040 回答
0

使用动态编程的解决方案的相对干净和经典的实现,应该提供保证的最佳解决方案(假设没有错误):

function [max_profit, Ncatch] = fish(nstart, nyear, grow_rate, dep_rate)
% return the maximum possible profit max_prof and a vector Ncatch which says
% how many fish to catch for each year

global cache

if isempty(cache) % init_cache
    maxfish = ceil(nstart * grow_rate^nyear);
    % allocate abundant cache space for dynamic programming
    cache.profit = nan(maxfish+1, nyear);
    cache.ncatch = cell(maxfish+1, nyear);
    % function calls are expensive, cache calls to revenue and cost
    cache.netprofit = arrayfun(@(i) revenue(i) - cost(i), 0:maxfish);
    cache.grow_rate = grow_rate;
    cache.dep_rate = dep_rate;
end

if ~isnan(cache.profit(nstart+1, nyear)) % found in cache
    max_profit = cache.profit(nstart+1, nyear);
    Ncatch = cache.ncatch{nstart+1, nyear};

    %assert(cache.grow_rate == grow_rate, 'clear cache first!')
    %assert(cache.dep_rate == dep_rate, 'clear cache first!')
    return 
end

max_profit = -inf;

if nyear == 1 % base case to stop recursion
    % simply get largest profit, future be damned
    [max_profit, imx] = max(cache.netprofit(1:nstart+1));
    Ncatch = [imx - 1];

else % recursive part
    for ncatch = 0:nstart % try all possible actions
        nleft = nstart - ncatch; % catch
        nleft = floor(grow_rate * nleft); % reproduce

        % recursive step, uses optimal profit for 1 year less
        [rec_profit, rec_Ncatch] = fish(nleft, nyear - 1, grow_rate, dep_rate); 

        profit = cache.netprofit(ncatch + 1) + dep_rate * rec_profit;
        if profit > max_profit
            max_profit = profit;
            Ncatch = [ncatch, rec_Ncatch];
        end
    end
end

% store result in cache
cache.profit(nstart+1, nyear) = max_profit;
cache.ncatch{nstart+1, nyear} = Ncatch;
end

function c = cost(x)
    if (x <= 5000)
        c = 0.4 * x + 100;
        return
    end
    if (x <= 10000)
        c = 0.3 * x + 5000;
        return
    end
    c = 0.2 * x + 10000;
end

function r = revenue(x)
    r = 5 .* x;
end

唯一的问题是它很慢,我猜运行时间类似于O(nyear * (nstart*grow_rate^(nyear-1))^2). 这是多项式时间 (?),但指数增长速率除外。(请注意,由于缓存,这仍然比蛮力解决方案要好,后者是O((nstart*grow_rate^(nyear-1))^nyear),它是 的指数nyear。)二次依赖nstart使它运行起来有点太慢nstart = 10000(可能大约一天),但因为nstart = 200它仍然在可接受的时间内运行。一些快速测试:

clear global % clear the cache

global cache

nyear = 10;
nstart = 200;
grow_rate = 1.2;
dep_rate = 0.80;

tic;
[profit, ncatch] = fish(nstart, nyear, grow_rate, dep_rate);
toc;

nfish = nstart;
for i = 1:nyear
    nnew = floor(grow_rate * (nfish - ncatch(i)));
    prof = cache.netprofit(ncatch(i) + 1);
    dep_prof = prof * (dep_rate)^(i-1);
    fprintf('year %d: start %d, catch %d, left %d, profit %.1f, dep. prof %.1f\n', ...
        i, nfish, ncatch(i), nnew, prof, dep_prof);
    nfish = nnew;
end
fprintf('Total profit: %.1f\n', profit);

结果

>> test_fish
Elapsed time is 58.591110 seconds.
year 1: start 200, catch 200, left 0, profit 820.0, dep. prof 820.0
year 2: start 0, catch 0, left 0, profit -100.0, dep. prof -80.0
year 3: start 0, catch 0, left 0, profit -100.0, dep. prof -64.0
year 4: start 0, catch 0, left 0, profit -100.0, dep. prof -51.2
year 5: start 0, catch 0, left 0, profit -100.0, dep. prof -41.0
year 6: start 0, catch 0, left 0, profit -100.0, dep. prof -32.8
year 7: start 0, catch 0, left 0, profit -100.0, dep. prof -26.2
year 8: start 0, catch 0, left 0, profit -100.0, dep. prof -21.0
year 9: start 0, catch 0, left 0, profit -100.0, dep. prof -16.8
year 10: start 0, catch 0, left 0, profit -100.0, dep. prof -13.4
Total profit: 473.6

因此折旧率如此之高,最佳解决方案是在第一年清空整个湖。稍微降低这个折旧率(dep_rate = 0.84;),情况发生了转变:

>> test_fish
Elapsed time is 55.872516 seconds.
year 1: start 200, catch 0, left 240, profit -100.0, dep. prof -100.0
year 2: start 240, catch 0, left 288, profit -100.0, dep. prof -84.0
year 3: start 288, catch 3, left 342, profit -86.2, dep. prof -60.8
year 4: start 342, catch 2, left 408, profit -90.8, dep. prof -53.8
year 5: start 408, catch 3, left 486, profit -86.2, dep. prof -42.9
year 6: start 486, catch 1, left 582, profit -95.4, dep. prof -39.9
year 7: start 582, catch 2, left 696, profit -90.8, dep. prof -31.9
year 8: start 696, catch 1, left 834, profit -95.4, dep. prof -28.2
year 9: start 834, catch 4, left 996, profit -81.6, dep. prof -20.2
year 10: start 996, catch 996, left 0, profit 4481.6, dep. prof 933.1
Total profit: 471.4

在这种情况下,增长速度高于贬值速度,因此最佳解决方案是让鱼尽可能长时间地繁殖,并在最后一年清空湖泊。有趣的是,该解决方案建议在中间年份捕获少量鱼。我假设这些额外的鱼不会改变nleft = floor(grow_rate * nleft). 玩一点dep_rate,这似乎是一个非常关键的全有或全无的情况:如果grow_rate 足够高,那么您在过去一年中钓到了所有东西。如果它太低,你在第一年就钓到所有东西。

于 2013-11-08T14:38:01.153 回答