#DynamicProgramming

[knowledge-sharing01]

Transformative Education: Discovering Dayanand Sagar University's Dynamic Programs and Resources

Embark on a journey of transformative education at Dayanand Sagar University, where a world of dynamic programs and abundant resources awaits eager minds. This distinguished institution is committed to redefining the educational landscape, offering a comprehensive range of programs designed to inspire and empower students.

Discover a curriculum that goes beyond traditional boundaries, fostering innovation, critical thinking, and practical skills. Dayanand Sagar University takes pride in its dynamic approach to education, constantly evolving to meet the demands of a rapidly changing world. Students are not just recipients of knowledge; they are active participants in their own learning, encouraged to explore, question, and create.

At the heart of this transformative experience are the diverse resources offered by the university. State-of-the-art facilities, cutting-edge laboratories, and a rich library provide students with the tools they need to excel in their chosen fields. The university's commitment to research and innovation ensures that students are at the forefront of emerging trends and technologies.

Whether you aspire to delve into the realms of engineering, business, sciences, or the arts, Dayanand Sagar University's dynamic programs cater to a spectrum of academic interests. The faculty, comprised of experienced professionals and industry experts, guide students through a learning journey that extends beyond textbooks to real-world applications.

Transformative education is not just a tagline; it is a philosophy embedded in every facet of Dayanand Sagar University. Discover an environment that nurtures intellectual curiosity, encourages collaboration, and prepares you for success in a globally competitive landscape. Your educational journey starts here – at Dayanand Sagar University, where transformation is not just a process but a promise.

[codewithsanika]

Pascal Triangle

In this tutorial, I walk you through step-by-step on how to approach Pascal Triangle🧠💡 Don't miss out on learning this essential algorithmic problem. Watch the video now and level up your programming skills! 💪💻 #Programming #Algorithm #PascalTriangle #LeetCode #Tutorial #ProblemSolving #JAVA #DynamicProgramming # Approach There are two conditions here 1) Condition - At the beginning and ending of each row we have 1 2)Recurrence Relation - which helps to use Dynamic Programming over here Steps: 1) Initialize List of List of Integer as Triangle 2) Triangle.add(new ArrayList) 3)Now add 1 to the first triangle(0)index 4)Now create new ArrayList for currRows and prevRows respectively 5)Add 1 to the beginning of currRows 6)For middle Numbers use recurrence relation (prevRows.get(col-1)+prevRows.get(col)) 7)Add 1 at the end of currRows 8)Return the triangle #Summary: Dynamic Programming is the technique use to breakdown the problems into subproblems and store the solution of subproblems. At the end use the subproblem solution to find out final solution #TimeComplexity : O(numRows2)

[fortunatelycoldengineer]

Binary Search . . . visit: https://bit.ly/3YyAWml for more information

[go-classes]

"Don't Be Greedy!!" - Matrix Chain Multiplication (MCM) #greedy #dynamicprogramming #GoClasses #algorithms #algo #computerscience #algorithm #greedyalgorithms https://www.instagram.com/p/CgEP0tJPKj8/?igshid=NGJjMDIxMWI=

[nehaarticles]

[gracesprojects]

MEng Design Engineering - Computing 2 Throwback to the programming Pacman challenge Funtimes programming, learning and competing :D

[love-thechosenone-blog]

I have just solved the "Princess Farida" challenge on SPOJ - https://www.spoj.com/FARIDA

[singerrkim-blog]

[BOJ]1010번 - 다리놓기

동적계획법 기초 문제 먼저 풀고 난 뒤, 친구에게 풀어보라고 줬더니 바로 조합이라고.. 조합을 생각하지 못한 나에 한번 더 반성하지만, 또 다른 점화식을 세웠다는 합리화로 조금 위로 하는걸로

글로 설명하기가 너무 복잡해 문제 풀이에 있는 주석을 참고해주시면 감사..

문제 풀이

[fortunatelycoldengineer]

Asymptotic Notation . . . visit: https://bit.ly/3YyAWml for more information

[weusegadgets]

MIT's Introduction to Algorithms, Lecture 16: Greedy Algorithms https://t.co/sittWaQl7p #dynamicprogramming #kruskalsalgorithm #minimumspanningtree #philipklein #edge #greedyalgorithm #videolecture #roberttarjan #mst #greedyalgorithms #mit #vertex #undirectedgraph

[javaaid-blog1]

Dynamic programming Introduction | What Is Dynamic programming | How To ...

[macronimous]

#DynamicProgramming vs Divide-and-Conquer https://t.co/s8a5KWIaLt

#DynamicProgramming vs Divide-and-Conquer https://t.co/s8a5KWIaLt

— Macronimous.com (@macronimous) June 27, 2018

from Twitter https://twitter.com/macronimous June 28, 2018 at 03:33AM via IFTTT

[100daysofalgorithms]

Day 34 - Fibonacci, final optimization of bottom up

Yesterday, we looked at a bottom up approach solving fibonacci numbers that runs in O(n) time.  That approach stores all previous numbers in memory, so if we were looking at Fib(241), we’d have to store 241 numbers.  But, realizing that we only really need to store the two previous numbers to calculate the current number, we can save space by only saving a reference to the two previous values.  Thus it can run in O(n) time, and use constant space by only storing 2 integers at any given time.

[45minutescoding]

Longest Increasting Subsequence and Patience Sorting

What this dynamic programming problem and the Solitaire game have in common is the Patience Sorting algorithm. It's easy to see how the elements are arranged, but it's not obvious how to reconstruct the longest increasing subsequence.

Suppose you have this list of numbers (if you want to play with cards, take a look here):

3, 2, 4, 7, 1, 5, 9, 6, 8

Let's try building piles by using these values such that each number can be placed only in the first pile whose top is larger than our number (Solitare game like). If no such pile can be found, a new pile is created.

Here is how it goes:

3, no pile found, it becomes the top of the new pile

2, it goes on first pile and becomes the new top

4, no pile found with larger top, create new pile

7, no pile found with larger top, create new pile

1, it goes on first pile and becomes the new top

5, it goes on the third pile  and becomes the new top

9, no pile found with larger top, create new pile

6, it goes on the fourth pile  and becomes the new top

8, no pile found with larger top, create new pile

Each time we add an element to a pile, we keep a reference to the top of the previous pile at that moment (if any), which represents, in fact, the previous element in the longest subsequence ending on the element we're adding.

Below how the piles look at the end (I added the references):

The number of piles represent the length of the longest increasing subsequence. We start with the top of the last pile and, by using references, we build the sequence.

Every time we add an element, we have to find the pile it belongs to. We are going to use a list that contains the top of each pile. This structure is ordered by the way of building it. Looking for the first element equal or greater than a value has the complexity of binary search, O(logN), therefore the time complexity of the algorithm is O(NlogN).

We will need additional structures for keeping the references and the piles, so the space complexity is O(N) (you can say P where P is the number of piles).

The code:

class HelperElement { public int Value { get; set; } public int? PreviousRef { get; set; } } public static IList<int> GetLongestIncreastingSubsequence(IList<int> list) { var result = new List<int>(); if (list.Count == 0) { return result; } var piles = new List<List<HelperElement>>(); var pileTops = new List<int>(); foreach (int element in list) { int pileIndex = 0; if (piles.Count == 0) { var pile = new List<HelperElement> { new HelperElement { Value = element } }; piles.Add(pile); } else { // find the pile to place the element pileIndex = Utils.FindFirstEqualOrHigher(pileTops, element, 0, pileTops.Count - 1); if (pileIndex == -1) { // no pile found, we'll create a new one pileIndex = piles.Count; piles.Add(new List()); } var pile = piles[pileIndex]; pile.Add(new HelperElement { Value = element }); // add pointer to the previous pile top element // will be used for tracking the sequence if (pileIndex > 0) { pile[pile.Count - 1].PreviousRef = piles[pileIndex - 1].Count - 1; } } if (pileTops.Count <= pileIndex) { pileTops.Add(element); } else { pileTops[pileIndex] = element; } } // build the longest increasing subsequence in descending order int? index = piles[piles.Count - 1].Count - 1; for (int i = piles.Count - 1; i >= 0; i--) { if (index.HasValue) { HelperElement element = piles[i][index.Value]; result.Add(element.Value); index = element.PreviousRef; } } // this can be avoided if the list is walked from right to end // searching for decreasing subsequences // however, it doesn't change complexity order result.Reverse(); return result; }

And if you want to take a look at the code that finds the first element equal or greater than a value:

public static int FindFirstEqualOrHigher(int[] array, int value, int left, int right) { if (left > right) { return -1; } if (left == right) { return array[left] >= value ? left : -1; } int half = left + (right - left) / 2; if (array[half] == value) { return half; } if (array[half] > value) { return FindFirstEqualOrHigher(array, value, left, half); } return FindFirstEqualOrHigher(array, value, half + 1, right); }

[antonio081014]

SRM302

Level 1Level 2Level 3Div 1Level 1Level 2Level 3Div 2Level 1Level 2Level 3

Tutorials:

Division One - Level Three:

Solution

Use Dynamic Programming. I was intentionally to use Trie to solve this problem, but I didn't find the hole to solve it. The detail is showed in the comment of code.

Source Code:

import java.util.ArrayList; import java.util.Arrays; import java.util.List; /** * @author: antonio081014 * * SRM302_DIV1_900.java * * */ public class JoinedString { private List<String> words; public void unique() { while (true) { boolean flag = false; for (int i = 0; i < words.size(); i++) { for (int j = 0; j < words.size(); j++) { if (i != j && words.get(i).contains(words.get(j))) { flag = true; words.remove(j); break; } } if (flag) break; } if (!flag) break; } } public String joinWords(String[] _words) { words = new ArrayList<String>(Arrays.asList(_words)); unique(); int N = words.size(); // for (int i = 0; i < N; i++) // System.out.println(words.get(i)); // append[i][j] is the string shared between string i and j, here the // string starts with j, ends with i; String[][] append = new String[N][N]; // mask[i][j] is the mask for appended string which shows the which // string is the substring of the appended string. int[][] mask = new int[N][N]; for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) append[i][j] = ""; for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) { if (i != j) { int minlen = Math.min(words.get(i).length(), words.get(j) .length()); while (minlen > 0) { if (words.get(j).endsWith( words.get(i).substring(0, minlen))) break; else minlen--; } // This is the shared part, which could be empty if there is // no common part. append[i][j] = words.get(j).substring(0, words.get(j).length() - minlen); // This is the combined string; String str = append[i][j] + words.get(i); for (int k = 0; k < N; k++) if (str.contains(words.get(k))) mask[i][j] |= 1 << k; } } // With the mask, shows the combined string which starts with string i; // The mask shows which string is the substring of this string; String[][] f = new String[1 << N][N]; for (int i = 0; i < 1 << N; i++) for (int j = 0; j < N; j++) f[i][j] = ""; // Initialization, each only has itself. for (int i = 0; i < N; i++) f[1 << i][i] = words.get(i); for (int i = 0; i < 1 << N; i++) { for (int j = 0; j < N; j++) { // it has a start; if (f[i][j].length() > 0) { for (int k = 0; k < N; k++) { // if mask i does not have all the string which combined // string of j, k has. if (k != j && (i | mask[j][k]) > i) { int newMask = i | mask[j][k]; String str = append[j][k] + f[i][j]; if (cmp(str, f[newMask][k])) f[newMask][k] = str; } } } } } String ret = ""; for (int i = 0; i < N; i++) // for each combined string, which has all the string as substring, // so mask has to be 11...1; string starts with ith string. we need // the smallest one; if (f[(1 << N) - 1][i].length() > 0 && cmp(f[(1 << N) - 1][i], ret)) ret = f[(1 << N) - 1][i]; return ret; } public boolean cmp(String a, String b) { if (b.length() == 0) return true; if (a.length() < b.length()) return true; if (a.length() == b.length() && a.compareTo(b) < 0) return true; return false; } }

Division One - Level Two:

Solution

Source Code:

Division One - Level One:

Solution

Source Code:

Sivision Two - Level Three:

Solution

Source Code:

Division Two - Level Two:

Solution

Source Code:

Division Two - Level One:

Solution

Source Code:

[fortunatelycoldengineer]

Algorithm Design Techniques . . . visit: https://bit.ly/3FIUADC for more information