首先，我想干净利落地说下面的问题是针对学校的，所以不要对我太苛刻:)
我在使用递归算法（这是一个要求）在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（数千的值）的情况。 这与book
中的“折扣利润问题”相同非常感谢您给我的任何帮助。
编辑1：我真的被困在这里。如果你能帮我实现这个，比如Java，我会尝试将它移植到Matlab。
编辑2：我将代码编辑为最新版本。现在我得到了
“达到最大递归限制500。”
你能帮助我吗？
编辑3：我设法让它工作但它只返回0.
编辑4：代码已更新。现在我得到了
尝试进入道具（2,0）; index必须是正整数或 逻辑。
Main（第66行）中的错误kq = prop（q，y）
答案 0 :(得分：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
再次阅读我的解决方案后，我有一些想法可以提高性能：
对于10000，它在可接受的时间内运行（大约5分钟），对于我建议更新的更大数据。
答案 1 :(得分：0)
使用dynamic programming的解决方案的相对干净和经典的实现，应该提供有保证的最佳解决方案（假设没有错误）：
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)。除了指数grow_rate之外，这是多项式时间（？）。 （请注意，由于缓存，这仍然比蛮力解决方案更好，它是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足够高，那么你去年就捕获了所有东西。如果它太低，你会在第一年捕获所有东西。