Professional Documents
Culture Documents
Asdfg
Asdfg
import java.io.*;
class Solution {
public int maxCoins(int[] nums) {
for(int g=0;g<dp.length;g++)
{
for(int i=0,j=g;j<dp.length;i++,j++)
{
int max = Integer.MIN_VALUE;
for(int k=i;k<=j;k++)
{
int left = k==i?0:dp[i][k-1];
int right = k==j?0:dp[k+1][j];
int value = (i == 0 ? 1:nums[i-1]) * nums[k] *
(j==nums.length-1? 1:nums[j+1]);
int total = left+right+value;
if(max<total)
max=total;
}
dp[i][j]=max;
}
}
return dp[0][nums.length-1];
}
}
int main()
{
int siz;
cin >> siz;
int A[siz];
for(int i=0;i<siz;i++)
cin >> A[i];
int ans = maxcoins(A);
cout << ans << endl;
return 0;
}
-------------------------------------------------------------------------
-------------------------------------------------------------------------
--------------
Bipartite
Graph
class Solution {
private int[][] graph;
private int n = 0;
public boolean isBipartite(int[][] graph) {
this.n = graph.length;
this.graph = graph;
int[] color = new int[n];
for(int i=0;i<n;i++)
color[i]=0; // 0->No color, 1->Red, 2->Blue
-------------------------------------------------------------------------
-------------------------------------------------------------------------
-------------------------------
Ominous Number
#include <iostream>
using namespace std;
while(temp){
digitArray[temp%10]++;
temp /= 10;
}
int rougeK = 0;
for(int i=0; i<n; i++){
rougeK += digitArray[delNos[i]];
}
}
return count;
}
int main() {
int a, b, k;
cin >> a >> b >> k;
int n;
cin >> n;
int *delNos = new int[n];
for(int i=0; i<n; i++){
cin >> delNos[i];
}
cout << numberOminous(a, b, k, delNos, n) << "\n";
return 0;
}
-------------------------------------------------------------------------
-------------------------------------------------------------------------
---------------------------------
String Compression
class Solution {
public:
int compress(vector<char>& chars) {
// if length is less than or equal to 2, return size of
char, because it can't be compressed
//if(chars.size() <= 2) return chars.size();
string ans = ""; // To store ans with count in string
format
int count = 0; // to store consecutive character
count
}
};
-------------------------------------------------------------------------
-------------------------------------------------------------------------
----------------------------------
Sum
K-level
// Java implementation to find sum of
// digits of elements at k-th level
class GfG {
else
{
// check if current level is
// the desired level or not
if (level == k)
sum += (tree.charAt(i)-'0');
}
}
// required sum
return sum;
}
-------------------------------------------------------------------------
-------------------------------------------------------------------------
----------------------------------
Spaceship
Bomb
import java.util.Scanner;
class SpaceshipSamsung {
}
}
-------------------------------------------------------------------------
-------------------------------------------------------------------------
-------------------------------------
AggressiveCows
-------------------------------------------------------------------------
-------------------------------------------------------------------------
-------------------------------------
Spaceship wormhole
#include <iostream>
#include <climits>
using namespace std;
void wormhole(int sX, int sY, int tX, int tY, int value){
ANS = min(ANS, dist(sX, sY, tX, tY) + value);
int main() {
int t, sX, sY, tX, tY;
cin >> t;
while(t--){
ANS = INT_MAX;
cin >> n;
cin >> sX >> sY >> tX >> tY;
for(int i=0; i<n; i++){
mask[i] = 0;
for(int j=0; j<5; j++){
cin >> w[i][j];
}
}
-------------------------------------------------------------------------
-------------------------------------------------------------------------
-----------------------------
MR. KIM
#include<iostream>
#include<climits>
using namespace std;
int x[20],y[20],n,ans;
int main(){
int tCases;
cin >> tCases;//For testcases
for(int i=0;i<tCases;i++){
ans=INT_MAX;//Set ans to max value
cin >> n;
cin >> x[n+1] >> y[n+1] >> x[0] >> y[0];//Input
destination and source x,y coordinates
for(int i=1;i<=n;i++){//Input drop off location
coordinates
cin >> x[i] >> y[i];
}
bool visited[n+2]={false};
optimalPath(0,visited,0,0);
cout << "#" << i+1 << " " << ans << endl;
}
return 0;
}
-------------------------------------------------------------------------
-------------------------------------------------------------------------
-------------------------------
MR.
LEE (Graph)
include<iostream>
#include<climits>
using namespace std;
int N, result;
// Main Case
for(int i=0; i<N; i++){
if(!visited[i] && arr[src][i] != 0){
visited[i] = true;
minCostMrLee(arr, visited, count + 1, cost +
arr[src][i], i);
visited[i] = false;
}
}
}
int main(){
int t;
cin >> t;
while(t--){
cin >> N;
int **arr = new int*[N];
for(int i=0; i<N; i++){
arr[i] = new int[N];
}
bool *visited = new bool[N];
result = INT_MAX;
visited[0] = true;
minCostMrLee(arr, visited, 0, 0, 0);
result != INT_MAX ? cout << result << "\n" : cout
<< "-1\n";
}
return 0;
}
-------------------------------------------------------------------------
-------------------------------------------------------------------------
-----------------------------------------
class Solution {
public int firstMissingPositive(int[] nums) {
boolean one = false;
int n = nums.length;
for(int i=0;i<n;i++)
{
if(nums[i]==1)
one=true;
if(nums[i]<1 || nums[i]>n)
nums[i]=1;
}
if(one == false)
return 1;
for(int i=0;i<n;i++)
{
int index = Math.abs(nums[i]);
nums[index-1] = -(Math.abs(nums[index-1]));
}
for(int i=0;i<n;i++)
{
if(nums[i]>0)
return i+1;
}
return n+1;
}
}