public class Runner {
    public static void main(String[] args) {
        int a[]={1,2,3};
        permutation(a,0);


    }

    private static void permutation(int[] a,int k) {
        if(k==a.length-1){
            System.out.println(Arrays.toString(a));
            return;
        }

        for (int i = k; i <a.length; i++) {
            int temp=a[k];
            a[k]=a[i];
            a[i]=temp;
            permutation(a,k+1);
             temp=a[k];
            a[k]=a[i];
            a[i]=temp;


        }

    }

}

public static void printSubSets(int arr[],int last,int k[]){
if(last==arr.length){
System.out.println(Arrays.toString(k));
return;
}int x = arr[last];
k[last] = x;
printSubSets(arr, last + 1, k);
k[last] = -1;

printSubSets(arr, last + 1, k);


}
public static void main(String[] args) {
int arr[]={1,2,3};
int k[]={-1,-1,-1};
printSubSets(arr,0,k);

}

public static int maxPath(int value[][],int x,int y){

if(x==0 || y==0){
return value[x][y];
}
int max= Integer.MIN_VALUE;


max = Math.max(maxPath(value,x-1,y),maxPath(value,x,y-1))+value[x][y];


return max;

}

public static int maxPath(int value[][],int x,int y,int memory[][]){

if(x==0 || y==0){
return value[x][y];
}
if(memory[x][y]!=Integer.MIN_VALUE){
return memory[x][y];
}
int max= Integer.MIN_VALUE;


max = Math.max(maxPath(value,x-1,y),maxPath(value,x,y-1))+value[x][y];

memory[x][y]=max;
return max;

}

public static void main(String[] args) {
int value[][]= {
{3,7,9,2,7},
{9,8,3,5,5},
{1,7,9,8,5},
{3,8,6,4,10},
{6,3,9,7,8}
};
int mem[][]= new int[5][5];
for(int i=0;i<mem.length;i++) {
Arrays.fill(mem[i],Integer.MIN_VALUE);
}
System.out.println(maxPath(value,4,4,mem));
}

public class KadaneAlgorithm {
public static int findMaxSubArray(int[] nums) {
int maxSoFar = nums[0];
int maxEndingHere = nums[0];

for (int i = 1; i < nums.length; i++) {
maxEndingHere = Math.max(nums[i], maxEndingHere + nums[i]);
maxSoFar = Math.max(maxSoFar, maxEndingHere);
}

return maxSoFar;
}

public static void main(String[] args) {
int[] nums = { -2, -3, 4, -1, -2, 1, 5, -3 };
int maxSum = findMaxSubArray(nums);
System.out.println("حداکثر مجموع زیرآرایه: " + maxSum);
}
}

public static int maxCoin(int n,int []price){

if(n==0){
return 0;
}
int q = Integer.MAX_VALUE;
for(int i=0;i<price.length;i++){
if(n- price[i]>=0) {
q = Math.min(maxCoin(n - price[i], price) + 1, q);
}
}
return q;
}

public static int dpMaxCoin(int n,int []price,int res[]){
if(n==0){
return 0;
}
if(res[n]>-1){
return res[n];
}else {
int q = Integer.MAX_VALUE;
for (int i = 0; i < price.length; i++) {
if (n - price[i] >= 0) {

q = Math.min(dpMaxCoin(n - price[i], price,res) + 1, q);
}
}
res[n]=q;

}
return res[n];
}

public static void main(String[] args) {
int [] arr = {1,3,4};
int res[] = new int[15];
Arrays.fill(res,-1);
System.out.println(maxCoin(14,arr));
System.out.println(dpMaxCoin(14,arr,res));

}

import java.lang.System.Logger;
import java.lang.System.Logger.Level;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ConnectToDatabase {

    private final static Logger LOGGER = System.getLogger(ConnectToDatabase.class.getName());

    private static final String URL_CONNECTION = "jdbc:mysql://localhost:3306/DBNAME";
    private static final String USERNAME = "";
    private static final String PASSWORD = "";

    private ConnectToDatabase() {
    }

    public static CompletableFuture<Connection> connectToDatabase() {
        CompletableFuture<Connection> connectionFuture = new CompletableFuture<>();
        final ExecutorService executorService = Executors.newSingleThreadExecutor();
        executorService.execute(() -> {
            try {
                final Connection connection = DriverManager.getConnection(URL_CONNECTION, USERNAME, PASSWORD);
                LOGGER.log(Level.INFO, "Successfully connection database");
                connectionFuture.complete(connection);
            } catch (SQLException e) {
                LOGGER.log(Level.ERROR, "Fail to connecting to database", e);
                connectionFuture.completeExceptionally(e);
            } finally {
                executorService.shutdown();
                LOGGER.log(Level.INFO, "Successfully shutdown executor");
            }
        });

        return connectionFuture;
    }

}

public static void main(String[] args) {
        int num[][]= {{-111,-18,-66},{-852,-112,12},{-132,-179,699}};
        int max = Integer.MIN_VALUE;
        for (int i = 0; i < num.length; i++) {
            for (int j = i; j < num.length; j++) {
                for (int k = 0; k <num[0].length ; k++) {

                    for (int l = k; l < num[0].length; l++) {
                        int nu=0;
                        for (int m = i; m <= j; m++) {
                            for (int n = k; n <=l ; n++) {
                               nu+=num[m][n];
                            }
                        }
                        if(nu>max){
                            max=nu;
                        }
                    }
                }
            }
        }
        System.out.println(max);
    }