버튼을 만들려고 하는데, 삭제버튼,수정버튼,완료버튼 모두 버튼이라는 하나의 공통점이 있다. 따라서 버튼 하나 하나 만들지 말고, props를 이용하여 만들어보자

필요한 props와 함께 버튼 컴포넌트를 생성해준다.

const MyButton = ({text,type,onClick}) => {
    return (
        <button className="{'MyButton}" onClick={onClick}>
            {text}
        </button>
    )
}

export default MyButton;

원하는 버튼 설정

 <MyButton
          text={'버튼'}
          onClick={() => alert('그냥 버튼')}
          type={"positive"}
        />

잘 나오는것을 볼 수 있다.

✔ 스타일

버튼 타입에 따라서 3가지 스타일을 만들어보도록 하자

그러기 위해서는 버튼 타입마다 className이 달라져야한다.

  <button className={["MyButton",`MyButton_${type}`].join(" ")} onClick={onClick}>

className은 문자열로 되어야하므로, 배열로 있던 요소들을 띄어쓰기와 함께 문자열로 만들면 완료. 이렇게 되면 MyButton이라는 className은 공통으로 들어가지만 MyButton_타입에 따라 달라지게 되므로 개별적으로 css를 추가해 줄 수 있다.

MyButton.defaultProps = {
    type:"default",
}

만약 type이 없으면 default로 잡아준다. 그런데 만약 type이 sSDFASDFASDASF이런 말같지도 않은걸로 전달되면 어떻게 처리해야할까?

const btnType = ['positive', 'negative'].includes(type) ? type : 'defualt';

positive나 negative에 속하지 않는다면 default타입으로 정해주면 된다!!

✔ props에 컴포넌트 넣기

이렇게 헤더를 만들건데, MyHeader.js라는 컴포넌트를 만들고 props를 통해서 버튼을 넣어 줄 수 있다. (신기행)

먼저 헤더를 만들어주고 필요한 props를 담아온다.

const MyHeader = ({headText,leftChild,rightChild}) => {
    return <header>
        <div className="head_btn_left">
            {leftChild}
        </div>
        <div className="head_text">
            {headText}
        </div>
        <div className="head_btn_right">
            {rightChild}
        </div>
    </header>
}

export default MyHeader;

<MyHeader
          headText={'header'}
          leftChild={<MyButton text={ '왼쪽 버튼'} onClick={()=>alert("왼쪽 클릭!")} />}
          rightChild={<MyButton text={ '오른쪽 버튼'} onClick={()=>alert("오른쪽 클릭!")} />}
          />

이렇게 넣어주면 완성!

만약에 onRemove를 onDelte라고 이름을 바꾸고 싶다면 매우 번거로울 것이다. props가 땅을 파고 드는것 같다고 해서 이 현상을 props drilling 이라고 한다!

여튼 이를 방지하기 위해서는 최상위 props를 하위 컴포넌트에서도 접근가능하게 하면 될것이다. Provider 컴포넌트를 이용하면 props를 직통으로 공급해주어 props drilling이 사라진다. 해당 provider가 공급하는 데이터에 접근할 수 있는 컴포넌트들의 영역을 Context라고 한다.

✔ useContext

const MyContext = React.createContext(defaultValue); // Context 생성

<MyContext.Provider value={전역으로 전달하고자하는 값}>
{/*이 context안에 위치할 자식 컴포넌트들*/}
</MyContext.Provider>

App.js에서 최상단으로 자식컴포넌트들을 감싸주고 data 값을 공급해준다. data값이 있으니 DiaryList의 dairylist props는 지워주면 됨. ㅎㅎ

 <DiaryStateContext.Provider value={data}>
    <div className="App">
      <DiaryEditor onCreate={ onCreate } />
       <div>전체 일기 : {data.length}</div>
      <div> 기분 좋은 일기 개수 : {goodCount}</div>
      <div>기분 나쁜 일기 개수:{badCount}</div>
      <div>기분 좋은 일기 비율:{ goodRatio }%</div>
      <DiaryList  onDelete={onDelete} onEdit={onEdit}/>
    </div>
    </DiaryStateContext.Provider>

DairyList 에서는 data를 받아야 하니까,

const diaryList = useContext(DiaryStateContext);

props drilling을 일으켰던, onEdit,onRemove를 해결해보자.. value에다가 data를 넣은듯이 두개를 넣으면 안된다! 왜냐하면,, provider도 컴포넌트이므로 data값이 바뀔때마다 계속 리렌더링 되어서, 최적화 시켰던 코드가 무용지물이 되기 때문이다!

✔ 이중 context

이를 해결하기 위해 context를 안에 더 넣어주면된다. onCreate,onEdit,onRemove 함수들을 재생성되지 않게 메모제이션 해주면 된다.

  const memoizedDispatches = useMemo(()=>{
    return {onCreate,onDelete,onEdit}
  },[])

✨완성✨

 <DiaryStateContext.Provider value={data}>
    <DiaryDispatchContext.Provider value={memoizedDispatches}>
    <div className="App">
      <DiaryEditor onCreate={ onCreate } />
       <div>전체 일기 : {data.length}</div>
      <div> 기분 좋은 일기 개수 : {goodCount}</div>
      <div>기분 나쁜 일기 개수:{badCount}</div>
      <div>기분 좋은 일기 비율:{ goodRatio }%</div>
      <DiaryList  onDelete={onDelete} onEdit={onEdit}/>
    </div>
    </DiaryDispatchContext.Provider>
    </DiaryStateContext.Provider>

data를 참조해야하기 때문에 App.js안에서만 상태관리가 이루어질 수 밖에 없다. 현재 app.js 코드가 길어서 넘 무거움..!!

목표: 상태변화 로직들을 컴포넌트에서 분리하여 좀 더 가볍게 만들기.

✔ useReducer

const [<상태 객체>, <dispatch 함수>] = useReducer(<reducer 함수>, <초기 상태>, <초기 함수>)

reducer 함수는 현재 state 객체,action 객체를 인자로 받아서 새로운 state를 리턴하는 함수이다. 행동객체는 reducer에서 어떤 행동을 할지 알려주는 type과, 그외에 필요한 데이터가 있으면 담을 수 있다.

dispatch가 필요한 데이터들을 싣고 reducer 상태 창고까지 가면, 거기서 가공을 해서 새로운 state를 배송하는 그런 느낌이다 ㅎㅎ dispatch가 버스같은 느낌~~

✔ 적용

const [data,dispatch] = useReducer(reducer,[]);

useState대신 useReducer를 넣어주었고, 초기값은 역시 빈배열이다! 처음에 getData() 함수에서 얻어낸 initData를 data 로 설정해주어야한다.

 dispatch({type:'INIT',data:initData})

getData 함수 안에 dispatch 버스를 initData를 태워서 보내주면 된다~🚙

 case 'INIT' :{
      return action.data;
    }

그러면 이제 data라는 상태는 initData로 변경이 된 것이다.

const reducer=(state,action)=>{
  switch(action.type){
    case 'INIT' :{
      return action.data;
    }
    case 'CREATE':{
      const created_date = new Date().getTime();
      const newItem = {
        ...action.data,
        created_date
      }
      return [newItem,...state]; // 새로운 값 + 원래 있던 배열
    }
    case 'REMOVE':{
      return state.filter((it)=> it.id !== action.targetId)
    }
    case 'EDIT':{
      return state.map((it)=> it.id === action.targetId? {...it,content:action.newContent} : it )
    }
    default: 
    return state;
  }
}

onCreate,onRemove,onEdit도 마찬가지로 type.action을 지정해 주어서 원하는 행동을 넣으면 된다.

1. 본인이 가진 state 가 변경될 때
2. 부모 컴포넌트가 리렌더링 될 떄
3. props가 변경될 때

일기를 수정하는데 네모칸이 리렌더링 될 필요는 없다.

✔ React.memo

React는 먼저 컴퍼넌트를 렌더링(rendering) 한 뒤, 이전 렌더된 결과와 비교하여 DOM 업데이트를 결정한다. 만약 렌더 결과가 이전과 다르다면, React는 DOM을 업데이트한다.

컴퍼넌트가 React.memo()로 래핑 될 때, React는 컴퍼넌트를 렌더링하고 결과를 메모이징(Memoizing)한다. 그리고 다음 렌더링이 일어날 때 props가 같다면, React는 메모이징(Memoizing)된 내용을 재사용한다.

즉,React.memo를 사용하면 일기 수정을 해도 네모 칸 부분인 DiaryEditor.js 의 props는 동일하므로 리렌더링을 방지 할 수 있다.

✔ 사용법

컴포넌트를 감싸서 React.memo를 해주거나

export default React.memo(DiaryEditor);

이렇게 해주면 완료~

✔ 더 확실히...

const DiaryEditor = ({ onCreate }) => {
    useEffect(() => {
        console.log("DiaryEditor 렌더");
    });

App.js에서 보낸 props인 onCreate 함수가 계속 변하기 때문에 DiaryEditor가 리렌더링 되는것이다. 왜냐하면 일기를 삭제하거나 새로 쓰면, 리렌더링이 되고 onCreate함수또한 새로 만들어지므로, 얕은 비교를 하기 때문에 onCreate이라는 props가 다르다고 판별되어 리렌더링 되는것이다.

결론은 onCreate 재생성을 막아서 최적화를 시키자!!!

✔ useCallback

위에서 한대로 useMemo를 이용하고 싶지만,, useMemo는 함수가 아닌 값을 리턴하는 것이므로 불가능하다. 따라서 useCallback을 사용해야한다.

const memoizedCallback = useCallback(
  () => {
    doSomething(a, b);
  },
  [a, b],
);

a,b가 바뀌지 않는다면 첫번째 인자로 받은 콜백함수를 재사용하는 훅이다.

여튼 이거를 onCreate함수에 적용시켜보았다.

  const onCreate = useCallback((author, content, emotion) => {
    const created_date = new Date().getTime();
    const newItem = {
      author,
      content,
      emotion,
      created_date,
      // id가 필요한데 이거는 변수처럼 이용해야함.
      id: dataId.current,
    };
    dataId.current += 1;

  },[]);

그러나 이렇게 하면 초기값이 []빈 배열인거로 기억하기 때문에 일기를 추가하면 전에 있던것이 빈배열 + 새로 추가한것 해서 1개만 생성이 된다. 이를 해결하기 위해서는 setData()를 이용해야한다. 저 안에

setData((data)=>[newItem,...data])

이걸 넣어주면 setData로 데이터를 불러와서 해결가능하다!

✔ 결과

일기를 삭제해도 리렌더링 되지 않는다.

이미 계산 해 본 연산 결과를 기억해 두었다가, 동일한 계산을 시키면 다시 연산하지 않고 기억해 두었던 데이터를 반환

✔ useMemo

const getDiaryAnalysis =()=>{
    console.log("일기 분석 시작");

    const goodCount = data.filter((it) => it.emotion >= 3).length;
    const badCount = data.length - goodCount;
    const goodRatio = (goodCount / data.length) * 100;
    return { goodCount, badCount, goodRatio };
    }

맨 처음에 getDiaryAnalysis함수는 2번실행된다. 왜냐하면 처음 마운트가 될때 (data가 빈배열이었을 때), 한 번 호출.

setData가 되면서 data가 한번 바뀐다. => app컴포넌트가 리렌더링 되면서 모든 함수가 재호출이 된다

❓ 그렇다면 일기를 수정할 때는 어떻게 될까?

data값이 바뀌므로 getDiaryAnalysis함수는 또 실행이 된다.

그러나 일기를 수정해도, 저 네모안의 값들은 바뀌지 않으므로, getDiaryAnalysis함수가 실행되는 것은 불필요하다. 따라서 useMemo를 사용해 보았다.

✔ 사용법

메모이제이션 하고 싶은 함수에 useMemo로 감싸준다. 첫번째 파라미터는 함수, 두번째 파라미터는 조건을 넣어준다. 즉 data.length가 일정할때 메모이제이션을 해주는 것이다.

  const getDiaryAnalysis = useMemo(
    () => { // 콜백함수
    console.log("일기 분석 시작");

    const goodCount = data.filter((it) => it.emotion >= 3).length;
    const badCount = data.length - goodCount;
    const goodRatio = (goodCount / data.length) * 100;
    return { goodCount, badCount, goodRatio };
    },[data.length]);

  const { goodCount, badCount, goodRatio } = getDiaryAnalysis;

리턴 값은 함수가 아닌 값을 리턴해준다.

상태값을 바로바로 업데이트 할 수 있다. const [<상태 값 저장 변수>, <상태 값 갱신 함수>] = useState(<상태 초기 값>);

import React, { useState } from 'react';

function Example() {
  // "count"라는 새로운 상태 값을 정의합니다.
  const [count, setCount] = useState(0);

  return (
    <div>
      <p>You clicked {count} times</p>
      <button onClick={() => setCount(count + 1)}>
        Click me
      </button>
    </div>
  );
}

✅ 응용

여기서 작성자, 내용, 기분옵션은 onChange 함수에 setState()를 줘서 바뀐값을 설정하는 방식이다. 따라서 하나하나 useState 변수를 주지 않고

 const [state, setState] = useState({
        author: "",
        content: "",
        emotion:1
    })

   const handleChangeState = (e) => {
        console.log(e.target.name);
        console.log(e.target.value);

        setState({
            ...state,
            [e.target.name]: e.target.value
        })
    }

로 해주어서, 스프레드연산 뒤 name과 키보드입력값(value)를 짝지어준다. onChange에 handleChangeState함수를 넣어주면 완성이다.

🚩 내 코드

public class 경로탐색_dfs {
    static  int n;
    static  int m;
    static  int [][] graph;
    static  int [] ch;
    static  int answer;
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        n = Integer.parseInt(scanner.next()); // 정점 수
        m = Integer.parseInt(scanner.next()); // 간선 수
        graph = new int[n+1][n+1];
        ch = new int[n+1];
        answer = 0;

        for(int i=0; i<m; i++){
            int a = scanner.nextInt();
            int b = scanner.nextInt();
            graph[a][b] = 1;
        }
        ch[1] = 1;
        dfs(1);
        System.out.println(answer);
    }
    private static void dfs(int v) {
        if(v==n){
            answer++;
        }else{
            for(int i=1; i<=n; i++){
                if(graph[v][i]==1 && ch[i]==0){
                    ch[i] = 1;
                    dfs(i);
                    ch[i] = 0; // 방문체크 풀어주기
                }
            }
        }
    }
}

💡 푼 방식

노드+1 만큼의 이차원배열을 만든 후, 연결되는 곳에 1을 넣는것으로 처음 설정을 해준다. (1과 3이 연결이라면 graph[1][3] = 1이렇게) 방향성이 있으므로, 꼭 첫번째꺼에서 두번째꺼 순서를 따져줘야함. (graph[3][1] = 1 이러면 방향이 반대라 안된다는 거임;;) 숫자 1부터 시작. ch[1]에 1을 넣어주어서 방문체크.(글랜체크 아님 ㅎ~)

이렇게 for문으로 각 노드와 연결된 노드를 찾아주고, 또 그 노드에서 다른 노드로 연결된걸 찾아주고,, 그게 5까지 가는지 확인해야하므로 dfs를 사용하였다.

📚 알게 된 정보

해당 노드를 방문체크를 하고 그 노드를 dfs넣은 후, 방문체크를 풀어줘야한다.

12-경로탐색(인접리스트)

위와 같은 문제지만, 노드가 10000개 이렇게 들어와버리면, 행렬로 풀기에는 너무 비효율적이다. 이번엔 다른방법..으로

🚩 내 코드

public class 경로탐색_인접리스트 {
    static  int n;
    static  int m;
    static ArrayList<ArrayList<Integer>> graph;
    static  int [] ch;
    static  int answer;
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        n = Integer.parseInt(scanner.next()); // 정점 수
        m = Integer.parseInt(scanner.next()); // 간선 수
        graph = new ArrayList<>();
        ch = new int[n+1];
        answer = 0;
        for(int i=0; i<=n; i++){ 
            graph.add(new ArrayList<>());// 정수를 저장할 수 있는 객체 생성.
        }
        for(int i=0; i<m; i++){
            int a = scanner.nextInt();
            int b = scanner.nextInt();
            graph.get(a).add(b);
        }
        ch[1]=1;
        dfs(1);
        System.out.println(answer);

    }
    private static void dfs(int v) {
        if(v==n){
            answer++;
        }else{
            for(int nv : graph.get(v)){ // v노드에 연결된 arraylist
                if(ch[nv]==0){
                    ch[nv] = 1;
                    dfs(nv);
                    ch[nv] = 0;
                }
            }
        }
    }
}

💡 푼 방식

ArrayList에 노드를 넣어주고, 그 노드에 연결된 노드 또한 넣어줘야하므로

ArrayList<ArrayList<Integer>> graph

로 생성해주었다. 위 방식으로 for문 도는거 대신에 각 노드들의 arrayList만 돌면 된다.

📚 알게 된 정보

ArrayList<ArrayList<Integer>> graph

13-그래프 최단 거리

🚩 내 코드

public class 그래프최단거리 {
    static int n,m;
    static int[] ch,dis;
    static ArrayList<ArrayList<Integer>> graph;
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        n = Integer.parseInt(scanner.next()); // 정점 수
        m = Integer.parseInt(scanner.next()); // 간선 수
        graph = new ArrayList<>();
        ch = new int[n+1];

        for(int i =0; i<=n; i++){
            graph.add(new ArrayList<>());
        }
        for(int i=0; i<m; i++){
            int a = scanner.nextInt();
            int b = scanner.nextInt();
            graph.get(a).add(b);
        }
        bfs(1);
        for(int i=1; i<dis.length; i++){
            System.out.println(dis[i]);
        }
    }

    private static void bfs(int v) {
        Queue<Integer> queue = new LinkedList<>();
        ch[v] = 1;
        dis[v] = 0;
        queue.offer(v);
        while(!queue.isEmpty()){
            int cv = queue.poll();
            for(int nv : graph.get(cv)){
                if(ch[nv] == 0){
                    ch[nv]=1;
                    queue.offer(nv);
                    dis[nv] = dis[cv]+1;
                }
            }
        }
    }
}

💡 푼 방식

최단이니까 bfs로 풀었다. 각 노드로 가는 회수는 dis배열에 넣었고,

dis[nextnode] = dis[currentnode]+1

로 회수를 세주었다.

📚 알게 된 정보

🚩 내 코드

  Scanner scanner = new Scanner(System.in);
        int N = Integer.parseInt(scanner.nextLine());
        String [] arr = scanner.nextLine().split("");

        HashMap<String, Integer> hm = new HashMap<>();
        for(String s : arr){
            hm.put(s,hm.getOrDefault(s,0)+1);
        }
        // ✔ 방법1.
        String answer="";
        int max = Integer.MIN_VALUE;
        for(String key : hm.keySet()){
            if(hm.get(key) > max){
                max = hm.get(key);
                answer=key;
            }
        }
        System.out.println(answer);

        // ✔ 방법2.
        // Collections.sort()를 사용하기 위해 List 형태로 Map을 가져와야함.
        List<Map.Entry<String,Integer>> entryList = new LinkedList<>(hm.entrySet());
        // 정렬 내장 함수 사용
        entryList.sort(Map.Entry.comparingByValue());
        for(Map.Entry<String, Integer> entry : entryList){
            //System.out.println("key: "+entry.getKey()+" value: "+entry.getValue());
        }

💡 푼 방식

HashMap 사용하여 알파벳과 개수를 짝지었다. 갯수는 map.getOrDefault함수를 사용하여, 찾는 키가 존재한다면 찾는 키의 값을 반환하고 없다면 기본 값을 반환한다. 따라서 내 코드에서는 찾는키가 없다면 0을 있다면 value를 반환하고 거기에 +1을 해줌으로써 개수를 세주는거다.

📚 알게 된 정보

굳이 정렬함수를 쓰지 않아도, max라는 변수를 이용하여 제일 큰 값을 찾아낼 수 있다. 정렬함수를 쓰기 위해서는 hashmap을 list형태로 변환해주어야한다. 참고

(4-2) 아나그램

🚩 내 코드

          Scanner scanner = new Scanner(System.in);
        HashMap<String,Integer> map1 = new HashMap<>();
        HashMap<String,Integer> map2 = new HashMap<>();
        String[] arr1 = scanner.nextLine().split("");
        String[] arr2 = scanner.nextLine().split("");

        for(String s : arr1){
            map1.put(s,map1.getOrDefault(s,0)+1);
        }

        String answer = "YES";
        // arr1과 비교하기
        for(String s : arr2){
            if(!map1.containsKey(s) || map1.get(s) == 0) { // 키가 없거나, value값이 다르다면
                answer="NO";
                break;
            }else{
                map1.put(s, map1.get(s)-1); // 키가 같은거에서는 1빼줌 (개수 세야되니까)
            }
        }
        System.out.println(answer);

💡 푼 방식

HashMap 사용하여 알파벳과 개수를 짝지었다. 갯수는 map.getOrDefault함수를 사용하여, 찾는 키가 존재한다면 찾는 키의 값을 반환하고 없다면 기본 값을 반환한다. 따라서 내 코드에서는 찾는키가 없다면 0을 있다면 value를 반환하고 거기에 +1을 해줌으로써 개수를 세주는거다. 그리고 다음 배열에서 있는 건 -1로 해서 개수를 맞춰본다.

📚 알게 된 정보

(4-3) 매출액의 종류

🚩 내 코드

           Scanner scanner = new Scanner(System.in);
        int N = Integer.parseInt(scanner.next());
        int K = Integer.parseInt(scanner.next());

        int [] arr = new int[N];
        for(int i=0; i<arr.length; i++){
            arr[i] = Integer.parseInt(scanner.next());
        }
        HashMap<Integer,Integer> map = new HashMap<>();
        for(int i=0; i<K; i++){
            map.put(arr[i],map.getOrDefault(arr[i],0)+1);
        }

        int size = map.size();
        System.out.print(size+" ");

        for(int i=0; i<N-K; i++){
            map.put(arr[i],map.getOrDefault(arr[i],0)-1);
            map.put(arr[i+K],map.getOrDefault(arr[i+K],0)+1);
            if(map.get(arr[i])==0){
                map.remove(arr[i]);
            }
            System.out.print(map.size()+" ");
        }

💡 푼 방식

HashMap 사용하여 매출액과 개수를 짝지었다. 갯수는 map.getOrDefault함수를 사용하였고, two Pointers 방식으로 따져보았다.

📚 알게 된 정보

hashmap + two pointers

(4-5) K번째 큰 수

🚩 내 코드

           Scanner scanner = new Scanner(System.in);
        int N = Integer.parseInt(scanner.next());
        int K = Integer.parseInt(scanner .next());
        int [] nums = new int[N];
        for(int i=0; i<N; i++){
            nums[i] = Integer.parseInt(scanner.next());
        }

        // 중복 피함
        TreeSet<Integer> tset = new TreeSet<>(Collections.reverseOrder());

        //3장을 뽑는 것이므로 3중 for문
        for(int i=0; i<N; i++){
            for (int j=i+1; j<N; j++){
                for(int l=j+1; l<N; l++){
                    tset.add(nums[i]+nums[j]+nums[l]);
                }
            }
        }
        int cnt=0;
        for(int x : tset){
            cnt++;
            if(cnt == K){
                System.out.println(x);
            }

💡 푼 방식

3중for문을 이용하여 숫자3개를 뽑았고 그 합을 TreeSet에 넣었다.

📚 알게 된 정보

3개를 어떻게 뽑지라고 고민했는데 그냥 3중for문을 쓰면 되는거였다. 합이 같은것이 여러개 나올 수 있는데, 중복을 제거하는 TreeSet에 넣으면 해결되었다.

treeset Set 인터페이스를 구현한 클래스로써 객체를 중복해서 저장할 수 없고 저장 순서가 유지되지 않는다는 Set의 성질

TreeSet<Integer> set1 = new TreeSet<Integer>();//TreeSet생성
TreeSet<Integer> set2 = new TreeSet<>();//new에서 타입 파라미터 생략가능
TreeSet<Integer> set3 = new TreeSet<Integer>(set1);//set1의 모든 값을 가진 TreeSet생성
TreeSet<Integer> set4 = new TreeSet<Integer>(Arrays.asList(1,2,3));//초기값 지정

TreeSet<Integer> tset = new TreeSet<>(Collections.reverseOrder());

TreeSet 참고1 TreeSet 참고2

🚩 내 코드

import java.util.LinkedList;
import java.util.Queue;

public class Solution {
    class Task{
        int location;
        int priority;
        public Task(int location, int priority) {
            this.location = location;
            this.priority = priority;
        }
    }
    public int solution(int[] priorities, int location) {
        int answer = 0;

        Queue<Task> queue = new LinkedList<>();

        for(int i=0; i<priorities.length; i++){
            queue.add(new Task(i, priorities[i]));
        }

        int now=0;
        while(!queue.isEmpty()){
            Task cur = queue.poll();
            boolean flag = false;
            for(Task t : queue){
                if(t.priority>cur.priority){
                    flag = true;
                }
            }
            if(flag) { // 우선순위 높은게 있으면 뒤로 보낸다
                queue.add(cur);
            }else{
                now++;
                if(cur.location == location) {
                    answer = now;
                    break;
                }

            }
        }
        return answer;
    }
}

💡 푼 방식

대기 목록을 task라는 클래스를 생성하여 큐에 넣었고, 클래스는 우선 순위와 위치 변수를 가졌다. 문제 그대로, 큐를 돌려서 해당 task가 큐안에 있는 task와 우선순위를 비교하여 우선순위가 높은 것이 있다면 뒤로 보냈다. 그렇지 않다면 위치를 확인하여 문제가 원하는 위치였던 task였으면 그것이 답이다.

📚 알게 된 정보

PriorityQueue

Queue 인터페이스의 구현체 중 하나, 저장 순서와 상관 없이 우선순위가 높은 것부터 꺼내진다.

PriorityQueue<Integer> queue = new PriorityQueue<>(Collections.reverseOrder()); // 이건 반대로

우선순위가 높은 것부터 꺼낸다 지, 우선순위가 높은 순으로 보관한다는 뜻이 아니다. 따라서 PriorityQueue를 그대로 출력했을 때와 실제로 요소를 하나씩 출력했을 때 표시되는 순서에는 차이가 있을 수 있다.

for(int priority:priorities){
    queue.offer(priority);
}

// 기존 배열에서 일치하는 문서 찾기
while(!queue.isEmpty()){
    for(int i=0; i<priorities.length; i++){
        if(queue.peek() == priorities[i]){
            if(i==location){
                return answer;
            }
            answer++;
            queue.poll();
        }
    }
}

🚩 내 코드

         Arrays.sort(a);
        Arrays.sort(b);

        int p1=0;
        int p2=0;
        ArrayList<Integer>al = new ArrayList<>();

        while (p1<n && p2<m){
            int i1 = Integer.parseInt(a[p1]);
            int i2 = Integer.parseInt(b[p2]);

            if(i1 > i2){
                p2++;
            }else if(i1 < i2){
                p1++;
            }else{
                al.add(i1);
                p1++;
                p2++;
            }
        }
        for(int i : al){
            System.out.print(i+" ");
        }

💡 푼 방식 두 배열을 오름차순으로 정렬 그리고 0인덱스부터 둘을 비교한다. a배열 요소가 더 크다면 b배열 인덱스를 +1 (그래야 b가 커지므로) b배열 요소가 더 크다면 a배열 인덱스를 +1 같다면 정답 배열에 추가 후 a,b배열 인덱스 모두 +1해준다.

📚 알게 된 정보 시간복잡도가 nlogn 그리고 공통원소를 찾는 과정을 O(n)

전체적으로는 시간복잡도는 O(nlogn)

(1-3) 최대매출

🚩 내 코드

          int N = Integer.parseInt(arr[0]);
        int K = Integer.parseInt(arr[1]);
        int [] days = new int[N];
        for(int i=0; i<N; i++){
            int money = scanner.nextInt();
            days[i] = money;
        }

        ArrayList<Integer> al = new ArrayList<>();
        int sum=0;
        int i=0;
        for(i=0; i<K; i++){
            sum+= days[i];
        }
        al.add(sum);
        for(int j=i; j<N; j++){
            sum-= days[j-K];
            sum+=days[j];
            al.add(sum);
        }
        Collections.sort(al);
        System.out.println(al.get(al.size()-1));

💡 푼 방식

먼저 k만큼의 요소를 더해서 arraylist에 넣는다. 그 뒤로 k만큼의 요소를 다시 계산해서 나아가는게 아니라 이미 계산한 값 sum에서 1번을 빼고 2번을 더해준다.

📚 알게 된 정보 기존값에서 변화량만 적용시켜주면 같은 행위를 반복하지 않아도 된다.

(1-4) 연속부분수열

🚩 내 코드

package two_pointers_sliding_window;
import java.util.Scanner;
public class 연속부분수열 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String[] arr = scanner.nextLine().split(" ");
        int n = Integer.parseInt(arr[0]);
        int m = Integer.parseInt(arr[1]);
        int [] numbers = new int[n];

        for(int i=0; i<n; i++){
            numbers[i] = scanner.nextInt();
        }

        int sum = 0;
        int lt = 0;
        int ans = 0;

        for(int rt=0; rt<n; rt++){
            sum+=numbers[rt];
            if(sum == m){
                ans++;
            }
            while (sum >= m ){
                sum-=numbers[lt++];
                if(sum == m){
                    ans++;
                }
            }
        }
        System.out.println(ans);
    }
}

💡 푼 방식 for문으로 rt는 0부터해서 sum이 m이 될때까지 더한다. 만약 sum==m이면 answer++ 그 후, while 문을 통해 lt가 가리키는 요소를 빼주고 lt는 한칸 오른쪽으로 가게 한다. 즉 rt는 for문으로 1씩 증가, 그 와중에 lt는 값을 비교하며 위치 변경

📚 알게 된 정보 two pointers알고리즘은 O(n^2)을 O(n)으로 바꿔주는 역할을 한다. 따라서 입력값이 엄청 클 때 사용하면 좋을듯..?!

(1-5) 연속된 자연수의 합

🚩 내 코드

         Scanner scanner = new Scanner(System.in);
        int n = Integer.parseInt(scanner.nextLine());

        int lt = 0;
        int ans = 0;
        int sum = 0;
        int m = n/2+1;
        int[] arr = new int[m];

        for(int i=0; i<m; i++){
            arr[i] = i+1;
        }

        for(int rt=0; rt<m;  rt++){
            sum+=arr[rt];
            if(sum == n){
                ans++;
            }
            while(sum >= n){
                sum-=arr[lt++];
                if(sum == n){
                    ans++;
                }
            }
        }
        System.out.println(ans);

💡 푼 방식 배열로 각 숫자를 넣어주고, lt rt를 활용한 위의 방법과 같다.

📚 알게 된 정보 수학적으로 접근할 수도 있다.

           Scanner scanner = new Scanner(System.in);
        int n = Integer.parseInt(scanner.nextLine());
        int ans = 0;
        int cnt = 1;
        n--; // 여기서 1 뺐고
        while(n>0){
            cnt++; //2돼서
            n=n-cnt; // 1과 2를 n에서 뺌.
            if(n%cnt == 0) ans++;
        }// cnt가 증가되고 빼지는 수도 계속 누적 됨.

(푸는중임)

🚩 내 코드

💡 푼 방식

rt lt 둘다 알파벳일때 서로 위치를 바꿀 수 있다. 만약 rt가 가르키는 곳이 알파벳이 아니라면 한칸 이동 (lt일 경우에도) rt가 lt보다 크지 않을 때까지 반복한다.

📚 알게 된 정보

(1-8) 유효한 팰린드롬

🚩 내 코드

Scanner scanner = new Scanner(System.in);
        String str = scanner.nextLine();
        // 대소문자 구분 없으므로 모두 대문자로 변환
        // 정규식 사용 (replaceAll만 정규식 사용가능)
        // 대문자 A-Z까지가 아니면
        str = str.toUpperCase().replaceAll("[^A-Z]","");

        String tmp = new StringBuilder(str).reverse().toString();
        if(str.equals(tmp)){
            System.out.println("YES");
        }else{
            System.out.println("NO");
        }

💡 푼 방식

오로지 알파벳만,대소문자 구분x 라는 규칙이 있으므로, 주어진 문자열을 모두 대문자로 전환했다. replaceAll과 정규식을 사용해 알파벳이외의 문자는 ""이거로 처리했다. stringBuilder로 거꾸로 해서 기존 문자열과 비교했다.

📚 알게 된 정보