Skip to main content

Moving on a Grid / Rock Climbing - Dynamic Programming


Imagine a climber trying to climb on top of a wall.  A wall is constructed out of square blocks of equal size. From each block, the climber can reach three blocks of the row right above: one right on top, one to the right and one to the left ( unless right or left not available because that is end of the wall ).
Find the least costly path from bottom to top where cost is the summation of costs of the blocks used on the path.

Problem Representation: An NxM size grid where each cell has a positive cost C(i,j) associated with it. There exists three possible moves from a cell (i,j) -
  • i+1,j-1     [ diagonally left ]
  • i+1. j       [ above ]
  • i+1.j+1     [ diagonally right ]

Take an array dp[ n ][ m ] that will hold the cost for all cells. Initiate dp[ 0 ][ i ] = C(0,i)  for 0 ≤ i ≤ m. There are three cases to the recurrence: a cell might be in the middle (horizontally), on the leftmost or on the rightmost sides of the grid. Thus, we compute dp[ i ][ j ] as follows- 

After all iteration, result is min( dp[ n ][ i ] ) for all 0 ≤ i ≤ m. To get the actuall path, call a function pathfinder recursively.
Problems to solve: Philosopher's Stone , Tri graphs

Comments

Popular posts from this blog

SPOJ - GSS1

Considering input series: { 4 , -10 , 3 , 100 , -20 , 1 } Query(x,y) = Max { a[i]+a[i+1]+...+a[j] ; x ≤ i ≤ j ≤ y } A node contains-  [ START & END is a node's segment limit ] Prefix is the maximum sum starting at START, end can be anywhere. There are two possibilities of the maximum. One, node's leftChild's prefix or two, adding leftChild's sum + rightChild's prefix. (which will make the prefix contiguous) Suffix is the maximum sum ending at END, start can be anywhere. There's two possibility of the maximum. One, node's rightChild's already calculated suffix or two, add rightChild's sum + leftChild's suffix   (which will make the suffix contiguous). Sum : leftChild's sum + rightChild's sum. MAX Maximum of  -  prefix (result is in the node, starts from START but doesn't end in END ) suffix  (result is in the node, doesn't start from START but surely ends in END ) leftChild's max ( result is in left ...

Bitwise Sieve w/ code sample

Sieve of Eratosthenes is explained HERE Bitwise sieve is an optimized implementation of  Sieve of Eratosthenes. It does the same thing but more memory efficient because it uses logic operations( &,|,>>,<< ) on binary numbers. In normal implementation, we use an array as flag to check if a number is prime or not.we know index of an array ( i.e  myarray[n]  ) is 32 bit long. If an array is 10 index long, that it has 32x10(=320) bits.  We use bits of that array as flag. that way we can flag numbers upto 320 as prime or not prime. i.e, how to check the flag status of 51 in myarray[ n ] ? We'll divide 5 by 32, that will give us the index number of the certain bit, then we'll mod 5 by 32, that will give us the certain bit position to check for 0 or 1. Remember bit positions are defined from right to left, starting from 0. Meaning LST = 0 and MST = 31. So we need to define two functions, one to set that certain bit as 0 or 1, another to check if...

SPOJ 5 - PALIN

Problem Statement Explanation is here Sample Solution : #include<bits/stdc++.h> using namespace std; char k[1000005]; int l,i,j,mid; bool chkNine() {     cout<<""; //for SPOJ's internal problem, this line is needed     for(i=0;i<l;i++)     {         if( k[i]!='9' ) return false;     } } void nextPalin() {     int f=0;     l=strlen(k);     if(chkNine()) {         memset(k,'0',l);         k[0] ='1';         k[l]='1';         k[l+1]='\0';         return;     }     // calc mid,i,j     if(l%2==0)     {         i= ( l/2 )-1;      ...