学习内容

LeeCodeJavaCSSHTML

888.公平的糖果棒交换

我的代码:

  1. class Solution {
  2.     public int[] fairCandySwap(int[] A, int[] B) {
  3.         int[] res=new int[2];
  4.         boolean flag=false;
  5.         //flag为false的情况即sumA>sumB
  6.         Arrays.sort(A);
  7.         Arrays.sort(B);
  8.         int sumA=getSum(A);
  9.         int sumB=getSum(B);
  10.         if(sumA<sumB){
  11.             int[] temp=A;
  12.             A=B;
  13.             B=temp;
  14.             int tempInt=sumA;
  15.             sumA=sumB;
  16.             sumB=tempInt;
  17.             flag=true;
  18.         }
  19.         int small;
  20.         int big;
  21.         for (int k : B) {
  22.             for (int j = A.length - 1; j >= 0; j--) {
  23.                 small = k;
  24.                 big = A[j];
  25.                 if (sumA - big + small == sumB - small + big) {
  26.                     if (flag) {
  27.                         res[0] = big;
  28.                         res[1] = small;
  29.                     } else {
  30.                         res[1] = big;
  31.                         res[0] = small;
  32.                     }
  33.                     return res;
  34.                 }
  35.             }
  36.         }return res;
  37.     }
  39.     int getSum(int[] a){
  40.         int count=0;
  41.         for (int j : a) {
  42.             count += j;
  43.         }
  44.         return count;
  45.     }
  46. }

思路:

将糖果棒按照从小到大进行排序,然后比较糖果棒总量大小,大的从后往前找,小的从后往前找,使用双重循环,当发现较大集合总数减这个数字,较小集合加这个数字,会使得两个相当,就可以返回了.

优解代码1

  1. class Solution {
  2.     public int[] fairCandySwap(int[] A, int[] B) {
  3.         int sumA = Arrays.stream(A).sum();
  4.         int sumB = Arrays.stream(B).sum();
  5.         int delta = (sumA - sumB) / 2;
  6.         Set<Integer> rec = new HashSet<Integer>();
  7.         for (int num : A) {
  8.             rec.add(num);
  9.         }
  10.         int[] ans = new int[2];
  11.         for (int y : B) {
  12.             int x = y + delta;
  13.             if (rec.contains(x)) {
  14.                 ans[0] = x;
  15.                 ans[1] = y;
  16.                 break;
  17.             }
  18.         }
  19.         return ans;
  20.     }
  21. }

思路:

其通过对于sumA - big + small == sumB - small + big进行化简,可得一个形如这样的算式big==(sumA-sumB)/2+small的算式,将A放入哈希表中,然后,逐个计算后面那个值,如果在hash表中存在则返回,无则找下一个.

优解代码2

  1. public int[] fairCandySwap(int[] A, int[] B) {
  2.         int diff = 0;
  3.         boolean[] flags = new boolean[100001];
  4.         for(int num: A)
  5.             diff -= num;
  6.         for(int num: B){
  7.             diff += num;
  8.             flags[num] = true;
  9.         }
  10.     //4-9是计算A与B的差值,并将B的值放到预设的哈希表中
  11.         diff /= 2;//数据加工
  12.         for(int num: A){
  13.             int numB = num + diff;
  14.             if(numB > 0 && numB < 100001 && flags[numB])
  15.                 return new int[]{num, num + diff};
  16.         }
  17.         return null;
  18.     }
  19. }

思路:

与上一个的思路类似,但是有以下优化:
1.使用有无数组取代了hashmap.
2.不计算两个数组的和直接计算他们的差
3.numB > 0 && numB < 100001这两个判断条件是为了去除Leecode给的脑瘫数据的影响.直接将其无视.
4.在这道题中,alice 的值必定比Bob少,这是一个隐含条件需要注意.

包裹浮动元素,开发实例,经验

包裹浮动元素

方法一(class选择器)

使用class选择器,对于最后一个,带有特定标志的容器,使用clear::both方法,即可使用.
不推荐.

方法二(伪元素选择器)

伪元素:

每个标签基本上会存在两个伪元素(一个在内容之前,一个在内容之后),
只不过他们没有值的时候被隐藏了,相当于两个被隐藏的标签.
需要改变属性:display:inline_block才可以改变属性(宽度,长度等).
伪元素选择器需要设定了content属性才能生效.

  1. span::before{
  2.   content:"";
  3.   <!---为标签添加内容的属性,输出的时候会带有一个" "-->
  4. }
  5. span::after{
  6.   content:"";
  7. }

使用方法:

clear命令

使用伪类选择器,选择目标标签的 after 伪元素选择器, 在选择器中加入 clear:both命令就可以将浮动元素的特性给关掉.

加入可视浮动元素的元素命令

添加诸如float:left/right``position:absoulute等命令,可以将内部元素变成inlineblock进而让浮动元素可视,进而可以相互影响乃至被包裹.

浮动的使用效果

图片浮于文字上方

在图片上设定float属性,可以在设定margin后有较明显的图片浮于文字上方的结果.