ধনাত্মক পূর্ণসংখ্যার সমন্বিত একটি ম্যাট্রিক্স দেওয়া হয়েছে, উপরের বাম উপাদান থেকে নীচের ডানদিকে ট্র্যাশ করার সময় সর্বনিম্ন যোগফলের সাথে পথ আউটপুট করুন। আপনি উল্লম্ব, অনুভূমিক এবং তির্যকভাবে স্থানান্তর করতে পারেন। মনে রাখবেন যে উপরের / নীচে, ডান / বাম এবং তির্যকভাবে সমস্ত দিক থেকে সরানো সম্ভব।

উদাহরণ:

 1*   9    7    3   10    2    2
10    4*   1*   1*   1*   7    8
 3    6    3    8    9    5*   7
 8   10    2    5    2    1*   4
 5    1    1    3    6    7    9*

সর্বনিম্ন যোগফলটি প্রদানে পাথাকে তারকাচিহ্নগুলির সাথে চিহ্নিত করা হয়েছে এবং এর ফলাফলের ফলাফল নিম্নলিখিত: 1 + 4 + 1 + 1 + 1 + 5 + 1 + 9 = 23 ।

পরীক্ষার কেস:

1   1   1
1   1   1
Output: 3

 7    9    6    6    4
 6    5    9    1    6
10    7   10    4    3
 4    2    2    3    7
 9    2    7    9    4
Output: 28

2  42   6   4   1
3  33   1   1   1
4  21   7  59   1
1   7   6  49   1
1   9   2  39   1
Output: 27 (2+3+4+7+7+1+1+1+1)

 5    6    7    4    4
12   12   25   25   25
 9    4   25    9    5
 7    4   25    1   12
 4    4    4    4    4
Output: 34 (5+12+4+4+4+1+4)

1   1   1   1
9   9   9   1
1   9   9   9
1   9   9   9
1   1   1   1
Output: 15

 2   55    5    3    1    1    4    1
 2   56    1   99   99   99   99    5
 3   57    5    2    2    2   99    1
 3   58    4    2    8    1   99    2
 4   65   66   67   68    3   99    3
 2    5    4    3    3    4   99    5
75   76   77   78   79   80   81    2
 5    4    5    1    1    3    3    2
Output: 67 (2+2+3+3+4+5+4+3+3+3+1+2+2+1+3+1+1+4+5+1+2+3+5+2+2)

এটি কোড-গল্ফ তাই প্রতিটি ভাষার সংক্ষিপ্ততম কোড জিততে পারে।

— স্টিও গ্রিফিন
সূত্র

খুব অনুরূপ , যদিও এটি তির্যক চলাচলের অনুমতি দেয় না।

— মেগো

7

@ উইট উইজার্ডের সাথে আমি একমত নই এই চ্যালেঞ্জটি তির্যক চলাফেরার জন্য এবং বেশিরভাগ অবস্থানের পক্ষে পৌঁছনীয় এমন বেশিরভাগ পর্যায়ে থাকা পার্থক্য ছাড়াও, অন্যান্য চ্যালেঞ্জের জন্য পথের ব্যয় ব্যয় না করে নিজেই ফিরে আসা দরকার। যদি না আপনি বিল্ট-ইনগুলি ব্যবহার করেন যা উভয়ই ফিরিয়ে দেয়, কোডটি বিনিময়যোগ্য নয়।

— বেকার

@ বেকার আমি আসলেই পার্থক্যটি দেখতে পাচ্ছি না। এর দৈর্ঘ্য জানতে আপনাকে পথ খুঁজে বের করতে হবে। পার্থক্যটি এখানে আমার মতে আউটপুটে একটি বরং ছোট পার্থক্য এবং এই চ্যালেঞ্জটি নতুন বা আকর্ষণীয় কিছুই সরবরাহ করে না যা ইতিমধ্যে সেই চ্যালেঞ্জের আওতায় নেই।

— গম উইজার্ড

1

@ ওয়েট উইজার্ড আমার সমাধানটি এখানে কোনও পথ খুঁজে পাচ্ছে না। এটা তোলে পারে পথ খুঁজে, কিন্তু একটি পৃথক পূর্বসুরী অ্যারে এবং যুক্তিবিদ্যা ছাড়া একটি নোড নিজস্ব পূর্বসুরী উপার্জন এড়ানো। শেষে পথ পুনরুদ্ধারের উল্লেখ না করা।

— বেকার

@ বেকার এই পরিবর্তনটি আমার মতে তুচ্ছ। ডুপসের প্রশ্ন নির্বিশেষে নয় যে একটি চ্যালেঞ্জের প্রতিটি বৈধ প্রবেশকে ন্যূনতম প্রচেষ্টা দিয়ে পোর্ট করা যেতে পারে, এটি সাধারণ ক্ষেত্রে সম্পর্কে নয়। আমি মনে করি না এখানে বেশিরভাগ প্রচেষ্টা পোর্ট করা যেতে পারে বলে আমি মনে করি না এই চ্যালেঞ্জটি অন্যটি থেকে নতুন বা আকর্ষণীয় কিছু সরবরাহ করে offers

— গম উইজার্ড

8

জাভাস্ক্রিপ্ট, 442 412 408 358 বাইট

এটি আমার প্রথম পিপিসি জমা। প্রতিক্রিয়া প্রশংসা করা হবে।

(m,h=m.length,w=m[0].length)=>{for(i=0;i<h*w;i++)for(x=0;x<w;x++){for(y=0;y<h;y++){if(m[y][x]%1==0)m[y][x]={c:m[y][x],t:m[y][x]};for(X=-1;X<=1;X++)for(Y=-1;Y<=1;Y++){t=x+X;v=y+Y;if((X==0&&Y==0)||t<0||t>=w||v<0||v>=h)continue;if(m[v][t]%1==0)m[v][t]={c:m[v][t],t:null};c=m[y][x].t+m[v][t].c;if (c<m[v][t].t||m[v][t].t==null)m[v][t].t=c}}}return m[h-1][w-1].t}

এটি ইনপুট হিসাবে বহুমাত্রিক অ্যারে নেয়।

ব্যাখ্যা

মূলত, প্রতিবেশীর প্রত্যেককে পাওয়ার জন্য সর্বনিম্ন জ্ঞাত ব্যয় সামঞ্জস্য করে ও উপরের সমস্ত কক্ষের মধ্য দিয়ে লুপ করুন। অবশেষে, গ্রিডটি এমন একটি স্থানে পৌঁছে যাবে যেখানে নীচের ডানদিকে পৌঁছানোর মোট ব্যয় সেখানে পৌঁছানোর সর্বনিম্ন ব্যয়।

ডেমো

f=(m,h=m.length,w=m[0].length)=>{for(i=0;i<h*w;i++)for(x=0;x<w;x++){for(y=0;y<h;y++){if(m[y][x]%1==0)m[y][x]={c:m[y][x],t:m[y][x]};for(X=-1;X<=1;X++)for(Y=-1;Y<=1;Y++){t=x+X;v=y+Y;if((X==0&&Y==0)||t<0||t>=w||v<0||v>=h)continue;if(m[v][t]%1==0)m[v][t]={c:m[v][t],t:null};c=m[y][x].t+m[v][t].c;if (c<m[v][t].t||m[v][t].t==null)m[v][t].t=c}}}return m[h-1][w-1].t}

//Tests
console.log(f([[1,1,1],[1,1,1]])===3);
console.log(f([[7,9,6,6,4],[6,5,9,1,6],[10,7,10,4,3],[4,2,2,3,7],[9,2,7,9,4]])===28);
console.log(f([[2,42,6,4,1],[3,33,1,1,1],[4,21,7,59,1],[1,7,6,49,1],[1,9,2,39,1]])===27);
console.log(f([[5,6,7,4,4],[12,12,25,25,25],[9,4,25,9,5],[7,4,25,1,12],[4,4,4,4,4]])===34); 
console.log(f([[1,1,1,1],[9,9,9,1],[1,9,9,9],[1,9,9,9],[1,1,1,1]])===15)
console.log(f([[2,55,5,3,1,1,4,1],[2,56,1,99,99,99,99,5],[3,57,5,2,2,2,99,1],[3,58,4,2,8,1,99,2],[4,65,66,67,68,3,99,3],[2,5,4,3,3,4,99,5],[75,76,77,78,79,80,81,2],[5,4,5,1,1,3,3,2]])===67);

স্নিপেট প্রসারিত করুন

সম্পাদনা: আমাকে কয়েক ডজন সুস্বাদু বাইট শেভ করতে সহায়তা করার জন্য @ ইটিএইচ প্রডাকশনগুলিকে বিশেষ ধন্যবাদ ।

আপনার টিপস যা 50 বাইট ছুঁড়েছে আপনার জন্য স্টিভি গ্রিফিনকে আরও ধন্যবাদ ।

— বেঞ্জামিন কুনিংহাম
সূত্র

3

পিপিসিজিতে আপনাকে স্বাগতম! শেষের দিকে আপনি সরিয়ে ফেলতে পারেন এমন আরও কয়েকটি স্পেস রয়েছে (আমি মোট 5 টি গণনা করি) এবং }কয়েকটি বাইট সংরক্ষণ করতে হবে এমন আগে আপনার সরাসরি কোনও সেমিকোলনের দরকার নেই । আপনার ভেরিয়েবলগুলি ঘোষণারও দরকার নেই; আমি মনে করি এসগুলি অপসারণ করাতে varআপনার মোট আরও 24 টি বাইট সংরক্ষণ করা উচিত।

— ETH প্রোডাকশন

2

পিপিসিগিতে আপনাকে স্বাগতম =) আমি আনন্দিত যে আপনি আমার চ্যালেঞ্জগুলির মধ্যে একটি প্রথম পয়েন্ট হিসাবে বেছে নিয়েছেন। আমার একমাত্র মন্তব্য: আমি ব্যাখ্যাগুলি পছন্দ করি। এটি যদিও alচ্ছিক, তাই আপনি না চাইলে আপনাকে এটি যুক্ত করতে হবে না। :)

— স্টিভি গ্রিফিন

আমার মনে হয় m[v][t]ভেরিয়েবল হিসাবে স্টোর করা: t=x+X;v=y+Y;k=m[v][t]এমনকি আরও খাটো হবে ...?

— স্টিভি গ্রিফিন

7

পাইথন 3 + নম্পি + স্কিপি , 239 222 186 বাইট

from numpy import*
from scipy.sparse.csgraph import*
def f(M):m,n=s=M.shape;x,y=indices(s);return dijkstra([(M*(abs(i//n-x)<2)*(abs(i%n-y)<2)).flatten()for i in range(m*n)])[0,-1]+M[0,0]

এটি অনলাইন চেষ্টা করুন!

— notjagan
সূত্র

6

অক্টাভা + ইমেজ প্রসেসিং প্যাকেজ, 175 162 157 151 142 139 বাইট

@ লুইস মেন্ডোকে 14 বাইট ধন্যবাদ এবং @ নটজাগানকে 1 বাইট ধন্যবাদ সংরক্ষণ করা হয়েছে

function P(G)A=inf(z=size(G));A(1)=G(1);for k=G(:)'B=im2col(padarray(A,[1,1],inf),[3,3])+G(:)';B(5,:)-=G(:)';A=reshape(min(B),z);end,A(end)

ইমেজ প্রসেসিং প্যাকেজ ব্যবহার করে, কেন নয়? সবাই কি গ্রাফ সমস্যা সমাধান করে না?

এটি অনলাইন চেষ্টা করুন!

বিস্ফোরিত

function P(G)
   A=inf(z=size(G));         % Initialize distance array to all Inf
   A(1)=G(1);                % Make A(1) = cost of start cell
   for k=G(:)'               % For a really long time...
      B=im2col(padarray(A,[1,1],inf),[3,3])+G(:)';
       %  B=padarray(A,[1,1],inf);     % Add border of Inf around distance array
       %  B=im2col(B,[3,3]);           % Turn each 3x3 neighborhood into a column
       %  B=B+G(:)';                   % Add the weights to each row
      B(5,:)-=G(:)';         % Subtract the weights from center of neighborhood
      A=reshape(min(B),z);   % Take minimum columnwise and reshape to original
   end
   A(end)                    % Display cost of getting to last cell

ব্যাখ্যা

ওজনের একটি অ্যারে দেওয়া:

7   12    6    2    4
5   13    3   11    1
4    7    2    9    3
4    2   12   13    4
9    2    7    9    4

ব্যয় অ্যারের সূচনা করুন যাতে প্রতিটি উপাদানের কাছে পৌঁছতে ব্যয় হয় অনন্ত, প্রারম্ভিক বিন্দু (উপরের বাম উপাদান) ব্যতীত যার ব্যয় তার ওজনের সমান হয়।

  7   Inf   Inf   Inf   Inf
Inf   Inf   Inf   Inf   Inf
Inf   Inf   Inf   Inf   Inf
Inf   Inf   Inf   Inf   Inf
Inf   Inf   Inf   Inf   Inf

এটি পুনরাবৃত্তি 0। প্রতিটি পরবর্তী পুনরাবৃত্তির জন্য, কোনও ঘরে পৌঁছানোর ব্যয়টি সর্বনিম্নতে সেট করা হয়:

এই উপাদানটিতে পৌঁছানোর জন্য বর্তমান ব্যয় এবং
উপাদানটির প্রতিবেশীদের কাছে পৌঁছানোর বর্তমান ব্যয় + উপাদানটির ওজন

প্রথম পুনরাবৃত্তির পরে, উপাদানটির পাথের ব্যয় (2,2) (1-ভিত্তিক সূচক ব্যবহার করে) হবে

minimum([  7   Inf   Inf]   [13  13  13]) = 20
        [Inf   Inf   Inf] + [13   0  13]
        [Inf   Inf   Inf]   [13  13  13]

প্রথম পুনরাবৃত্তির পরে সম্পূর্ণ ব্যয়ের অ্যারেটি হ'ল:

  7    19   Inf   Inf   Inf
 12    20   Inf   Inf   Inf
Inf   Inf   Inf   Inf   Inf
Inf   Inf   Inf   Inf   Inf
Inf   Inf   Inf   Inf   Inf

পুনরাবৃত্তির পরে k, প্রতিটি উপাদানই বেশিরভাগ kপদক্ষেপ গ্রহণ করা শুরু থেকে সেই উপাদানটিতে পৌঁছানোর সর্বনিম্ন ব্যয় হবে । উদাহরণস্বরূপ, (3,3) এ উপাদানটি 22 টির জন্য 2 ধাপে (পুনরাবৃত্তি) পৌঁছে যেতে পারে:

  7    19    25   Inf   Inf
 12    20    22   Inf   Inf
 16    19    22   Inf   Inf
Inf   Inf   Inf   Inf   Inf
Inf   Inf   Inf   Inf   Inf

তবে চতুর্থ পুনরাবৃত্তিতে 4 টি ধাপের পথ 20 টি ব্যয়ের সাথে পাওয়া যায়:

 7   19   25   24   28
12   20   22   32   25
16   19   20   30   34
20   18   30   34   35
27   20   25   40   39

যেহেতু এমএক্সএন ম্যাট্রিক্সের কোনও পথ ম্যাট্রিক্সের উপাদানগুলির সংখ্যার চেয়ে লম্বা হতে পারে না (খুব আলগা উপরের আবদ্ধ হিসাবে), m*nপুনরাবৃত্তির পরে প্রতিটি উপাদান সূচনা থেকে সেই উপাদানটিতে পৌঁছানোর জন্য সবচেয়ে সংক্ষিপ্ত পথের ব্যয় ধারণ করবে।

— পানপাত্র
সূত্র

whileএবং এর মধ্যে স্থানটি সরিয়ে -1 বাইট ~।

— notjagan

@notjagan আমি থেকে সুইচ whileকরতে forএবং এখনও আপনার টিপের ব্যবহার করতে সক্ষম হন। ধন্যবাদ!

— বেকার

5

জাভাস্ক্রিপ্ট, 197 বাইট

a=>(v=a.map(x=>x.map(_=>1/0)),v[0][0]=a[0][0],q=[...(a+'')].map(_=>v=v.map((l,y)=>l.map((c,x)=>Math.min(c,...[...'012345678'].map(c=>a[y][x]+((v[y+(c/3|0)-1]||[])[x+c%3-1]||1/0)))))),v.pop().pop())

মনোরম:

a=>(
  // v is a matrix holds minimal distance to the left top
  v=a.map(x=>x.map(_=>1/0)),
  v[0][0]=a[0][0],
  q=[
     // iterate more than width * height times to ensure the answer is correct
    ...(a+'')
  ].map(_=>
    v=v.map((l,y)=>
      l.map((c,x)=>
        // update each cell
        Math.min(c,...[...'012345678'].map(
          c=>a[y][x]+((v[y+(c/3|0)-1]||[])[x+c%3-1]||1/0)
        ))
      )
    )
  ),
  // get result at right bottom
  v.pop().pop()
)

— TSH
সূত্র

4

গণিত 279 বাইট

বুনিয়াদি ধারণাটি হ'ল ম্যাট্রিক্স এন্ট্রি এবং নির্দেশিত প্রান্তগুলির সাথে মিলিত ChessboardDistanceশূন্যের চেয়ে বৃহত্তর কিন্তু 1 বা তার সমান কম দ্বারা বিভক্ত যে কোনও দুটি শীর্ষের মধ্যে নির্দেশিত প্রান্তের সাথে সম্পর্কিত একটি গ্রাফ তৈরি করা উচিত ঘটনাচক্রে, এটি কিং গ্রাফ হিসাবে পরিচিত হতে পারে , কারণ এটি এর সাথে সম্পর্কিত দাবা বোর্ডে রাজার বৈধ পদক্ষেপ।

FindShortestPathএর পরে সর্বনিম্ন পাথ পেতে ব্যবহৃত হয়। এটি কাজ করে EdgeWeight, না VertexWeight, সুতরাং EdgeWeightপ্রতিটি নির্দেশিত প্রান্তের গন্তব্যের সাথে মিলিত ম্যাট্রিক্স এন্ট্রি হিসাবে সংজ্ঞায়িত করার জন্য অতিরিক্ত কিছু কোড রয়েছে ।

কোড:

(m=Flatten[#];d=Dimensions@#;s=Range[Times@@d];e=Select[Tuples[s,2],0<ChessboardDistance@@(#/.Thread[s->({Ceiling[#/d[[1]]],Mod[#,d[[1]],1]}&/@s)])≤1&];Tr[FindShortestPath[Graph[s,#[[1]]->#[[2]]&/@e,EdgeWeight->(Last@#&/@Map[Extract[m,#]&,e,{2}])],1,Last@s]/.Thread[s->m]])&

নোট করুন যে চরিত্রটি হ'ল ট্রান্সপোজ প্রতীক। এটি ম্যাথামেটিকায় যেমন রয়েছে তেমন পেস্ট করবে।

ব্যবহার:

%@{{2, 55, 5, 3, 1, 1, 4, 1},
  {2, 56, 1, 99, 99, 99, 99, 5},
  {3, 57, 5, 2, 2, 2, 99, 1},
  {3, 58, 4, 2, 8, 1, 99, 2},
  {4, 65, 66, 67, 68, 3, 99, 3},
  {2, 5, 4, 3, 3, 4, 99, 5},
  {75, 76, 77, 78, 79, 80, 81, 2},
  {5, 4, 5, 1, 1, 3, 3, 2}}

আউটপুট:

যদি আপনি সেট করেন g=Graph[...,GraphLayout->{"GridEmbedding","Dimension"->d},VertexLabels->Thread[s->m]এবং p=FindShortestPath[...তারপরে নিম্নলিখিত গ্রাফিকটি দৃশ্যত সমাধানটি প্রদর্শন করবে (ম্যাট্রিক্সের শীর্ষটি গ্রাফের নীচের সাথে মিলে যায়):

HighlightGraph[g,PathGraph[p,Thread[Most@p->Rest@p]]]

— কেলি লোদার
সূত্র

3

হাস্কেল, 228 বাইট

অবস্থানগুলি দুটি উপাদানগুলির তালিকা, কারণ এগুলি উত্পন্ন sequenceকরা সহজ এবং 2-টিউপলসের মতো প্যাটার্ন মেলাতেও সহজ।

h=g[[-1,-1]]
g t@(p:r)c|p==m=0|1<2=minimum$(sum$concat c):(\q@[a,b]->c!!a!!b+g(q:t)c)#(f(e$s$(\x->[0..x])#m)$f(not.e t)$zipWith(+)p#s[[-1..1],[-1..1]])where m=[l(c)-1,l(head c)-1]
(#)=map
f=filter
e=flip elem
s=sequence
l=length

শুরু হবে -1,-1প্রতিটি পদক্ষেপের গন্তব্য ক্ষেত্রের দাম এবং গণনা করুন।

বিকল্প প্রথম দুটি লাইন: প্রারম্ভের 0,0ক্ষেত্রগুলি গণনা করুন, ম্যাট্রিক্সের মাত্রার সমান স্থানাঙ্কে সমাপ্ত করুন (লক্ষ্য থেকে ডান-ডান, যা আইনি গন্তব্যের তালিকায় যুক্ত হওয়া প্রয়োজন) - সঠিক একই দৈর্ঘ্য তবে ধীর:

j=i[[0,0]]
i t@(p@[a,b]:r)c|p==m=0|1<2=c!!a!!b+(minimum$(sum$concat c):(\q->i(q:t)c)#(f(e$m:(s$(\x->[0..x-1])#m))$f(not.e t)$zipWith(+)p#s[[-1..1],[-1..1]]))where m=[l c,l$head c]

এখানে একটি ইনফিক্স ব্যবহার করা mapবাইটগুলি সংরক্ষণ করে না তবে এটির জন্য একটি ব্যয় না হওয়ার সাথে সাথেই আমি এটির বিকল্প তৈরি করেছি, কারণ এটি কেবল আরও ব্যবহারের সাথে এবং কখনও কখনও অন্যান্য পুনর্গঠনগুলির সাথে আরও ভাল হয়ে উঠতে পারে যা অন্য জোড়া বন্ধনী বন্ধ করে দেয়।

উন্নত করতে: রিডানডেন্ট filterএস। মার্জ / ইন-আবরণের তাদের filter(flip elem$(s$(\x->[0..x])#m)\\p)সঙ্গে import Data.Listজন্য \\3 খরচ বাইট।

এছাড়াও, খুব খারাপ (fromEnumTo 0)2 বাইটের চেয়ে দীর্ঘ হয় (\x->[0..x])।

sum$concat cসমস্ত ক্ষেত্রের ব্যয়ের সংক্ষিপ্তসার এবং এইভাবে একটি minimumখালি তালিকা এড়ানোর জন্য দেওয়া পথের ব্যয়ের উপর একটি সংক্ষিপ্তভাবে প্রকাশযোগ্য উপরের আবদ্ধ (আমার টাইপ চেকার ইতিমধ্যে সম্পূর্ণরূপে এটি কাজ করার জন্য নির্ধারিত করেছে Integer, তাই সর্বাধিক কোনও হার্ড-কোডিং নয় , হি)। আমি আগের যেটি তৈরি করেছি তার উপর ভিত্তি করে পদক্ষেপগুলিকে কীভাবে সীমাবদ্ধ রাখি না (যেটি অ্যালগরিদমকে অনেক গতিবেগ করে তোলে, তবে ব্যয়ের ব্যয়ও বর্ধিত হয়), আমি এই পতন ব্যাকটিকে প্রয়োজনীয় করে তোলে এমন মরা প্রান্তগুলি এড়াতে পারি না।

একটি ফিল্টার ধারণা ((not.e n).zipWith(-)(head r))উত্তোলনের সাথে ছিল n=s[[-1..1],[-1..1]], যা ,[-1,-1]প্রাথমিক পথে যোগ করা প্রয়োজন । এরপরেই অ্যালগরিদম যেখানে পূর্ববর্তী পদক্ষেপে ইতিমধ্যে যেতে পারত সেখানে যাওয়া এড়িয়ে যায়, যা একটি প্রান্ত ক্ষেত্রের দিকে অরথোগোনালিভাবে একটি প্রান্তে পা রেখে দেয়।
আরেকটি ছিল ((>=0).sum.z(*)d)এক্সট্রাক্টিংয়ের সাথে z=zipWith, যা dপুনরাবৃত্তির ক্রিয়াকলাপের জন্য একটি নতুন যুক্তি উপস্থাপন করে যা পুনরাবৃত্তির হিসাবে (z(-)p q)এবং [1,1]প্রাথমিক ক্ষেত্রে দেওয়া হয়। অ্যালগরিদম একটি নেতিবাচক স্কেলার পণ্য ( dপূর্ববর্তী পদক্ষেপ হচ্ছে) সহ ধারাবাহিক পদক্ষেপগুলি এড়িয়ে চলে , যার অর্থ কোন ধারালো 45 °-টর্নস নয়। এটি এখনও পছন্দগুলি যথেষ্ট পরিমাণে সঙ্কুচিত করে এবং পূর্ববর্তী তুচ্ছ ডেড এন্ডটি এড়িয়ে যায়, তবে এখনও এমন কয়েকটি পথ রয়েছে যা ইতিমধ্যে পরিদর্শন করা ক্ষেত্রগুলিতে আবদ্ধ থাকে (এবং সম্ভবত একটি 'পালানো' যা তীব্র মোড় হবে)।

— লাইফ উইলার্টস
সূত্র

3

পাইথন 2, 356 320 বাইট

s=input()
r=lambda x:[x-1,x,x+1][-x-2:]
w=lambda z:[z+[(x,y)]for x in r(z[-1][0])for y in r(z[-1][1])if x<len(s)>0==((x,y)in z)<len(s[0])>y]
l=len(s)-1,len(s[0])-1
f=lambda x:all(l in y for y in x)and x or f([a for b in[l in z and[z]or w(z)for z in x]for a in b])
print min(sum(s[a][b]for(a,b)in x)for x in f([[(0,0)]]))

এখানে চেষ্টা করুন!

নটজাগানকে ধন্যবাদ -36 বাইট !

ইনপুট হিসাবে তালিকার একটি তালিকা প্রাপ্ত করে এবং ম্যাট্রিক্স উপরের বাম থেকে নীচে ডানদিকে নেভিগেট করার সময় সর্বনিম্ন ব্যয় আউটপুট করে।

ব্যাখ্যা

প্রতিটি রুটের জন্য x, y স্থানাঙ্কের একটি তালিকা তৈরি করে ম্যাট্রিক্সের উপরের বাম থেকে নীচে ডানদিকে প্রতিটি সম্ভাব্য রুট সন্ধান করুন। রুটগুলি ব্যাকট্র্যাক করতে পারে না এবং এগুলি অবশ্যই শেষ হবে (len(s)-1,len(s[0])-1)।

স্থানাঙ্কের প্রতিটি পথে পূর্ণসংখ্যা যোগ করুন এবং সর্বনিম্ন ব্যয়টি ফিরিয়ে দিন।

printসহজে আউটপুট সংক্ষিপ্ত রুটের জন্য স্থানাঙ্ক তালিকা পরিবর্তন করা যাবে।

— Solvation
সূত্র

কিছু বিবিধ পরিবর্তন সহ -৩। বাইট ।

— notjagan

@ ননতাজাগান দুর্দান্ত পরিবর্তন, বিশেষত orশর্তসাপেক্ষে ব্যবহার । ধন্যবাদ!

— সলভেশন

1

এপিএল (ডায়ালগ ক্লাসিক) , 33 বাইট

{⊃⌽,(⊢⌊⍵+(⍉3⌊/⊣/,⊢,⊢/)⍣2)⍣≡+\+⍀⍵}

এটি অনলাইন চেষ্টা করুন!

{ } যুক্তি দিয়ে ফাংশন ⍵

+\+⍀⍵ পথের দূরত্বগুলিতে একটি অনিরাপদ উপরের সীমানা প্রতিষ্ঠার জন্য সারি এবং কলাম দ্বারা আংশিক অঙ্কগুলি গ্রহণ করুন

( )⍣≡ একীকরণ পর্যন্ত পুনরাবৃত্তি:

(⍉3⌊/⊣/,⊢,⊢/)⍣2প্রতিবেশীদের দূরত্বের মিনিট, অর্থাৎ দুইবার করুন ( ( )⍣2): বামতম স্তম্ভটি প্রিপেন্ড করুন (⊣/, ) থেকে নিজেকে ( ⊢) উপস্থাপন করুন এবং ডানদিকের কলামগুলি সংযোজন করুন ,⊢/), অনুভূমিক ত্রিভুজের মধ্যে মিনিমা সন্ধান করুন ( 3⌊/) এবং ট্রান্সপোজ ( ⍉)
⍵+ প্রতি নোডের মূল্য প্রতি মিনিটের দূরত্বের সাথে যুক্ত করুন
⊢⌊ বর্তমানের সেরা দূরত্বকে হারাতে চেষ্টা করুন

⊃⌽, অবশেষে, নীচের ডান কক্ষটি ফিরিয়ে দিন

— ngn
সূত্র

একটি ম্যাট্রিক্সের মাধ্যমে সর্বোত্তম পথ

উদাহরণ:

পরীক্ষার কেস:

জাভাস্ক্রিপ্ট, 442 412 408 358 বাইট

ব্যাখ্যা

ডেমো

পাইথন 3 + নম্পি + স্কিপি , 239 222 186 বাইট

অক্টাভা + ইমেজ প্রসেসিং প্যাকেজ, 175 162 157 151 142 139 বাইট

জাভাস্ক্রিপ্ট, 197 বাইট

গণিত 279 বাইট

হাস্কেল, 228 বাইট

পাইথন 2, 356 320 বাইট

ব্যাখ্যা

এপিএল (ডায়ালগ ক্লাসিক) , 33 বাইট