Advertisement
Guest User

Untitled

a guest
Jan 8th, 2016
66
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 7.08 KB | None | 0 0
  1.  
  2. public class GreedyAlgorithm {
  3. public static void main(String[] args){
  4.  
  5. Parcel A = new Parcel(2,20,24,'A');
  6. Parcel B = new Parcel(3,20,30,'B');
  7. Parcel C = new Parcel(Math.pow(1.5, 3),10,8,'C');
  8. char[][][] container = new char[33][5][8];
  9.  
  10. for(int i=0; i<container.length; i++){
  11. for(int j=0; j<container[0][1].length; j++){
  12. for(int k=0; k<container[1].length; k++)
  13. container[i][k][j] = ' ';
  14. }
  15. }
  16. //Hardcoding of the different possible order
  17. if(A.RATIO > B.RATIO && B.RATIO > C.RATIO){
  18. Parcel[] allParcels1 = {A,B,C};
  19. load(container,allParcels1);
  20. }
  21. if(A.RATIO > C.RATIO && C.RATIO > B.RATIO){
  22. Parcel[] allParcels2 = {A,C,B};
  23. load(container,allParcels2);
  24. }
  25. if(B.RATIO > A.RATIO && A.RATIO > C.RATIO){
  26. Parcel[] allParcels3 = {B,A,C};
  27. load(container,allParcels3);
  28. }
  29. if(B.RATIO > C.RATIO && C.RATIO > A.RATIO){
  30. Parcel[] allParcels4 = {B,C,A};
  31. load(container,allParcels4);
  32. }
  33. if(C.RATIO > A.RATIO && A.RATIO > B.RATIO){
  34. Parcel[] allParcels5 = {C,A,B};
  35.  
  36. load(container,allParcels5);
  37. }
  38. if(C.RATIO > B.RATIO && B.RATIO > A.RATIO){
  39. Parcel[] allParcels6 = {C,B,A};
  40. load(container,allParcels6);
  41. }
  42.  
  43. printArray(container);
  44. getLoadInfo(container,A,B,C);
  45. System.out.println("Finished");
  46. }
  47.  
  48. public static void load(char[][][] container, Parcel[] allParcels){
  49. //Try to place all piece with the best ratio first
  50. while(allParcels[0].quantity>0 && enoughSpace(container,allParcels[0])){
  51. for(int i=0; i<container.length; i++){
  52. for(int k=0; k<container[0][1].length; k++){
  53. for(int j=0; j<container[i].length; j++){
  54. if(allParcels[0].quantity>0){
  55. if(container[i][j][k] == ' '){
  56. if(itFits(container,allParcels[0],i,j,k)){
  57. drawParcel(container,allParcels[0],i,j,k);
  58. allParcels[0].quantity--;
  59. }
  60. }
  61. }
  62. }
  63. }
  64. }
  65. }
  66.  
  67. //To avoid useless computation
  68. if(isFull(container))
  69. return;
  70. //second most valuable pieces and so on
  71. while(allParcels[1].quantity>0 && enoughSpace(container,allParcels[1])){
  72. for(int i=0; i<container.length; i++){
  73. for(int k=0; k<container[0][1].length; k++){
  74. for(int j=0; j<container[i].length; j++){
  75. if(allParcels[1].quantity>0){
  76. if(container[i][j][k] == ' '){
  77. if(itFits(container,allParcels[1],i,j,k)){
  78. drawParcel(container,allParcels[1],i,j,k);
  79. allParcels[1].quantity--;
  80. //printArray(container);
  81. }
  82. }
  83. }
  84. }
  85. }
  86. }
  87. }
  88. //To avoid useless computation
  89. if(isFull(container))
  90. return;
  91.  
  92. while(allParcels[2].quantity>0 && enoughSpace(container,allParcels[2])){
  93. for(int i=0; i<container.length; i++){
  94. for(int k=0; k<container[0][1].length; k++){
  95. for(int j=0; j<container[i].length; j++){
  96. if(allParcels[2].quantity>0){
  97. if(container[i][j][k] == ' '){
  98. if(itFits(container,allParcels[2],i,j,k)){
  99. drawParcel(container,allParcels[2],i,j,k);
  100. allParcels[2].quantity--;
  101. }
  102. }
  103. }
  104. }
  105. }
  106. }
  107. }
  108. }
  109.  
  110. public static boolean itFits(char[][][] container, Parcel parcel,int i, int j, int k){
  111. boolean enoughSpace = true;
  112. if(parcel.letter =='A'){
  113. for(int z=k; z<k+4;z++){
  114. for(int x=i; x<i+2; x++){
  115. for(int y=j; y<j+2; y++){
  116. if(x<container.length && y<container[0].length && z<container[0][1].length){
  117. if(container[x][y][z] != ' '){
  118. enoughSpace = false;
  119. return enoughSpace;
  120. }
  121. }
  122. else{
  123. enoughSpace = false;
  124. return enoughSpace;
  125. }
  126. }
  127. }
  128. }
  129. }
  130. if(parcel.letter =='B'){
  131. for(int z=k; z<k+4;z++){
  132. for(int x=i; x<i+2; x++){
  133. for(int y=j; y<j+3;y++){
  134. if(x<container.length && y<container[0].length && z< container[0][1].length){
  135. if(container[x][y][z] != ' '){
  136. enoughSpace = false;
  137. return enoughSpace;
  138. }
  139. }
  140. else{
  141. enoughSpace = false;
  142. return enoughSpace;
  143. }
  144. }
  145. }
  146. }
  147. }
  148. if(parcel.letter =='C'){
  149. for(int z=k; z<k+3;z++){
  150. for(int x=i; x<i+3; x++){
  151. for(int y=j; y<j+3;y++){
  152. if(x<container.length && y< container[0].length && z< container[0][1].length){
  153. if(container[x][y][z] != ' '){
  154. enoughSpace = false;
  155. return enoughSpace;
  156. }
  157. }
  158. else{
  159. enoughSpace = false;
  160. return enoughSpace;
  161. }
  162. }
  163. }
  164. }
  165. }
  166. return enoughSpace;
  167. }
  168.  
  169. public static void drawParcel(char[][][] container, Parcel parcel,int i, int j, int k ){
  170.  
  171. if(parcel.letter =='A'){
  172. for(int z=k; z<k+4;z++){
  173. for(int x=i; x<i+2; x++){
  174. for(int y=j; y<j+2;y++){
  175. if(x<container.length && y<container[0].length && z< container[0][1].length){
  176. container[x][y][z] = parcel.letter;
  177. }
  178. }
  179. }
  180. }
  181. }
  182. if(parcel.letter =='B'){
  183. for(int z=k; z<k+4;z++){
  184. for(int x=i; x<i+2; x++){
  185. for(int y=j; y<j+3;y++){
  186. container[x][y][z] = parcel.letter;
  187. }
  188. }
  189. }
  190. }
  191. if(parcel.letter =='C'){
  192. for(int z=k; z<k+3;z++){
  193. for(int x=i; x<i+3; x++){
  194. for(int y=j; y<j+3;y++){
  195. container[x][y][z] = parcel.letter;
  196. }
  197. }
  198. }
  199. }
  200. }
  201. public static boolean isFull(char[][][] container){
  202. for(int i=0; i<container.length; i++){
  203. for(int j=0; j<container[0][1].length; j++){
  204. for(int k=0; k<container[1].length; k++){
  205. if(container[i][k][j] == ' ')
  206. return false;
  207. }
  208. }
  209. }
  210. return true;
  211. }
  212.  
  213. public static void printArray(char[][][] container){
  214. int counter=1;
  215. for(int k=0; k<container[0][1].length; k++){
  216. if(counter==1 && k==0)
  217. System.out.println("Layer : "+counter);
  218. for(int i=0; i<container.length; i++){
  219. for(int j=0; j<container[i].length; j++){
  220. System.out.print(container[i][j][k]);
  221. }
  222. System.out.println(" ");
  223. }
  224. System.out.println(" ");
  225. counter++;
  226. if(counter<9)
  227. System.out.println("LAYER : "+counter);
  228. }
  229. }
  230.  
  231. public static boolean enoughSpace(char[][][] container,Parcel parcel){
  232. for(int i=0; i<container.length; i++){
  233. for(int k=0; k<container[0][1].length; k++){
  234. for(int j=0; j<container[i].length; j++){
  235. if(itFits(container,parcel,i,j,k)){
  236. return true;
  237. }
  238. }
  239. }
  240. }
  241. return false;
  242. }
  243. public static void getLoadInfo(char[][][] container, Parcel A, Parcel B, Parcel C){
  244. int numberA=0;
  245. int numberB=0;
  246. int numberC=0;
  247. int blankSpace=0;
  248. for(int i=0; i<container.length; i++){
  249. for(int k=0; k<container[0][1].length; k++){
  250. for(int j=0; j<container[i].length; j++){
  251. if(container[i][j][k] == 'A')
  252. numberA++;
  253. if(container[i][j][k] =='B')
  254. numberB++;
  255. if(container[i][j][k] =='C')
  256. numberC++;
  257. if(container[i][j][k] ==' ')
  258. blankSpace++;
  259. }
  260. }
  261. }
  262. numberA= numberA/16;
  263. numberB= numberB/24;
  264. numberC= numberC/27;
  265. double price = numberA*A.PRICE + numberB*B.PRICE + numberC*C.PRICE;
  266. System.out.println("Load value = "+price+" (A: "+numberA+" B: "+numberB+" C: "+numberC+" Space: "+blankSpace+")");
  267. }
  268. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement