diff --git a/README.md b/README.md index c29a49c..deafe98 100644 --- a/README.md +++ b/README.md @@ -1,336 +1,201 @@ # ncrc-pairing -엑셀 파일을 입력받아 위원 페어 후보와 센터 배정 후보를 만들고, Google OR-Tools CP-SAT으로 배정 결과를 계산하는 Spring Boot API입니다. +엑셀 파일을 입력받아 위원 조편성 및 센터 방문 일정을 생성하는 Spring Boot API입니다. + +현재 배정 엔진은 Greedy 중심으로 동작합니다. 모든 위원을 먼저 조편성하고, 이후 가능한 많은 센터를 일정표에 배정합니다. OR-Tools CP-SAT 코드는 유지되어 있지만 전체 배정의 중심 경로는 `PairingScheduleService`입니다. ## 실행 흐름 1. `PairingController` - `/api/v1/pairing/run`으로 엑셀 파일을 업로드받습니다. - - 처리 결과를 엑셀 파일로 반환합니다. + - 결과 엑셀 파일을 반환합니다. 2. `PairingService` - - 전체 유스케이스 흐름을 순서대로 호출합니다. - - `엑셀 읽기 -> 정규화 -> 공휴일 반영 -> 검증 -> 후보 생성 -> solver 실행 -> 결과 엑셀 생성` + - 전체 유스케이스를 순서대로 호출합니다. + - `엑셀 읽기 -> 정규화 -> 공휴일/주말 반영 -> 검증 -> 후보 생성 -> 조편성/스케줄링 -> 결과 엑셀 생성` 3. `PairingExcelService` - - 입력 엑셀의 6개 시트를 `dto.excel` DTO로 읽습니다. - - 결과 엑셀은 `배정결과`, `미배정센터`, `미사용위원`, `처리요약`, `AB페어목록`, `후보요약`, `검증오류`, `규칙위반검사` 시트로 씁니다. - - `/run`에서 입력/검증 오류가 발생하면 오류 내용을 담은 엑셀 파일을 반환합니다. + - 입력 엑셀 시트를 DTO로 읽습니다. + - 결과 시트는 배정결과, 미배정센터, 미사용위원, 처리요약, AB페어목록, 후보요약, 검증오류, 규칙위반검사를 포함합니다. 4. `PairingNormalizeService` - 엑셀 문자열을 내부 모델로 변환합니다. - - 날짜, CSV, 성별, 경력여부, 현장/외부 구분, 지역코드, 선호지역을 정리합니다. + - 날짜, CSV, 성별, 경력, 현장/외부 구분, 지역코드, 희망지역을 정리합니다. -5. `PairingValidationService` - - 필수 데이터, 날짜 범위, 지자체 참조, 희망지역 매칭표 등을 검증합니다. - - 실패 시 `BusinessException.badRequest(code, message)`를 사용합니다. +5. `PairingHolidayService` + - `DatagoHolidayCache`를 통해 공휴일을 조회합니다. + - 토/일은 `DatagoHolidayCache#getWeekend`에서 생성해 공통 불가능일로 합칩니다. + - 공휴일 API 조회 실패 시 구동되면 안 된다는 정책에 따라 실패 응답을 냅니다. -6. `PairingHolidayService` - - `DatagoExtentionApiClient.getHoliDayList(year)`로 국공휴일을 조회합니다. - - 조회된 날짜는 모든 위원/지자체/센터에 공통 적용되는 진행 불가일자로 처리합니다. - - 공휴일 목록은 `DatagoHolidayCache`에서 공용 `AbstractListCache` 기반으로 캐싱합니다. +6. `PairingValidationService` + - 필수 데이터, 날짜 범위, 지자체 참조, 희망지역 매칭표를 검증합니다. + - 검증 실패는 `BusinessException.badRequest(code, message)`를 사용합니다. 7. `PairingCandidateService` - - solver가 선택할 수 있는 후보만 생성합니다. - - 불가능한 조합은 이 단계에서 제거합니다. + - 가능한 조, 파견권역, 센터/날짜 후보를 생성합니다. + - 상피제, 여성전용센터, 기방문센터, 날짜 불가, 공휴일/주말 등 명확한 Hard Rule을 후보 단계에서 제거합니다. -8. `PairingSolverService` - - OR-Tools CP-SAT 모델을 만들고 최적 배정을 계산합니다. +8. `PairingMemberPairService` + - 모든 위원이 최소 1개 조에 포함되도록 조편성을 먼저 수행합니다. + - 센터/날짜 후보가 많은 조를 우선 선택하고, 위원당 상대 파트너 수 상한을 지킵니다. -## OR-Tools 사용 개요 +9. `PairingScheduleService` + - 확정된 조를 기준으로 센터 일정을 Greedy 방식으로 배정합니다. + - 이후 repair pass를 통해 미배정 센터 감소와 방문 수 균형을 보정합니다. -현재 사용하는 라이브러리는 `com.google.ortools:ortools-java`입니다. +10. `PairingSolverService` + - 결과 DTO 생성과 규칙 위반 검사를 담당합니다. + - CP-SAT 기반 선택 로직도 유지하고 있으나 현재 주 경로는 Greedy 스케줄링입니다. -OR-Tools CP-SAT은 "조건을 만족하는 조합 중 점수가 가장 좋은 조합"을 찾는 최적화 solver입니다. 이 프로젝트에서는 각 배정 후보를 boolean 변수로 만듭니다. +## 현재 Hard Rule -예를 들어 어떤 후보가 다음 의미를 가진다고 하면: +| 규칙 | 구현 위치 | +| --- | --- | +| 모든 위원은 최소 1개 조에 포함 | `PairingMemberPairService`, `PairingSolverService#checkAllMembersUsed` | +| 현장위원 + 외부위원 조 구성 | `PairingCandidateService#createPairCandidates` | +| 위원 활동 가능 기간 겹침 | `PairingCandidateService#hasDateOverlap` | +| 상피제 | `PairingCandidateService#isConflictRegion` | +| 여성전용센터는 여성 2명 조만 허용 | `PairingCandidateService#findCenterHardRuleReasons` | +| 기방문센터 제외 | `PairingCandidateService#findCenterHardRuleReasons` | +| 위원/지자체/센터 불가능일 제외 | `PairingCandidateService#findAssignableDates`, `isAvailableOn` | +| 공휴일/토/일 제외 | `PairingHolidayService`, `DatagoHolidayCache`, `PairingCandidateService#commonUnavailableDates` | +| 센터 1개는 최대 1번 배정 | `PairingScheduleService#isFeasible`, `PairingSolverService#addCenterAssignedAtMostOnce` | +| 한 위원은 같은 날짜에 다른 조와 중복 활동 불가 | `PairingScheduleService#isFeasible`, `GreedyState#isMemberBusyWithOtherPair` | +| 같은 조는 하루 최대 N개 센터 방문 | `application.yaml`, `PairingScheduleService#isFeasible` | +| 같은 조/같은 날짜에는 하나의 인접지역 분류만 방문 | `PairingScheduleService#isFeasible`, `GreedyState#isAllowedAdjacentClassification` | +| 위원당 상대 파트너 수 최대 N명 | `application.yaml`, `PairingMemberPairService`, `PairingScheduleService#isFeasible` | +| 위원별 최대 방문 수 상한 | `application.yaml`, `PairingScheduleService#maxMemberVisitCount` | -```text -2026-05-01에 fieldMember=100, externalMember=200 페어가 center=300을 방문한다 +## 현재 Soft Rule 우선순위 + +1. 배정 센터 수 최대화 +2. 위원별 방문 수 균형 +3. 희망지역 매칭표 우선순위 +4. 희망지역 99 wildcard fallback +5. 거주지 유사도 +6. 같은 조/같은 날짜/같은 인접지역 분류 재사용 + +관련 설정: + +```yaml +pairing: + rule: + max-centers-per-pair-per-day: 3 + max-counterparts-per-member: 3 + max-member-visit-average-ratio-percent: 130 + preference: + anywhere-rank: 0 + ignored-rank: 99 + active-wildcard-fallback-enabled: true + wildcard-fallback-score-bonus: 25_000 + objective: + assignment-weight: 1_000_000 + member-balance-weight: 20_000 + preference-base-weight: 30_000 + preference-rank-penalty: 1_000 + residence-match-weight: 10_000 + candidate: + max-pair-candidates-per-member: 0 + max-dispatch-regions-per-pair: 0 + max-assignments-per-center: 1_000 + max-assignments-per-member: 3_000 + max-dates-per-assignment-candidate: 80 ``` -solver 안에서는 이 후보가 하나의 `BoolVar`가 됩니다. +## Greedy 스케줄링 구조 + +핵심 파일: `PairingScheduleService` + +1. `pairingCandidateService.generate` + - 가능한 후보를 생성합니다. + +2. `pairingMemberPairService.select` + - 모든 위원을 먼저 조편성합니다. + +3. `assignRemainingCenters` + - 후보가 적은 센터부터 선택합니다. + - 해당 센터에 가능한 후보 중 점수가 가장 높은 후보를 배정합니다. + +4. `repairUnassignedCenters` + - 미배정 센터를 넣기 위해 기존 충돌 배정을 최대 2개까지 제거하고 다시 채웁니다. + +5. `repairLowVisitMembers` + - 방문 수가 적은 위원이 남은 센터에 들어갈 수 있는지 우선 탐색합니다. + +6. `repairByDonorSwap` + - 방문 수가 많은 위원의 배정을 저방문 위원이 포함된 후보로 넘길 수 있는지 봅니다. + +7. `repairWildcardFallbackCenters` + - 99 wildcard 후보를 남은 센터에 우선 적용해 봅니다. + +## OR-Tools CP-SAT 설명 + +사용 라이브러리: + +```gradle +implementation("com.google.ortools:ortools-java:9.15.6755") +``` + +CP-SAT는 "조건을 모두 지키면서 가장 점수가 높은 조합을 찾는 도구"입니다. + +예를 들어 `A조가 2026-05-01에 100번 센터를 방문한다`라는 후보가 있으면, CP-SAT 안에서는 이 후보가 0/1 변수 하나가 됩니다. ```text 1 = 이 후보를 선택한다 0 = 이 후보를 선택하지 않는다 ``` -`PairingSolverService`는 이런 boolean 변수들을 놓고 아래를 수행합니다. - -- hard rule: 반드시 지켜야 하는 제약 -- soft rule: 지키면 점수가 좋아지는 목표 - -## 현재 적용된 Hard Rule - -후보 생성 단계와 solver 단계에 나뉘어 적용되어 있습니다. - -### 후보 생성 단계 - -위치: `PairingCandidateService` - -- 현장위원 + 외부위원 페어만 생성 -- 신규 + 신규 페어 제외 -- 두 위원의 일정 범위가 겹치지 않으면 제외 -- 파견 권역이 위원의 활동지역과 같으면 제외 -- 희망지역 매칭표에 없는 선호 조합 제외 -- 센터 인접지역표를 통해 파견 권역과 센터 연결 -- 여성 전용 센터는 여성 2명 페어만 허용 -- 2023년 진행 센터는 해당 위원에게 재배정 금지 -- 위원/지자체/센터의 시작일, 종료일, 불가일자를 모두 반영 -- 국공휴일은 모든 배정 후보에서 제외 - -현재 후보 수 폭증을 막기 위해 각 페어/센터 조합에서 가장 빠른 feasible 일자 1개만 후보로 만듭니다. - -### Solver 단계 - -위치: `PairingSolverService` - -- 한 센터는 최대 1번만 배정 -- 한 페어는 하루 최대 3개 센터만 방문 -- 한 위원은 같은 날짜에 하나의 페어로만 활동 -- 한 페어는 같은 날짜에 하나의 인접지역 분류만 방문 -- 한 위원은 전체 기간 동안 최대 2명의 상대 파트너만 가짐 - -## 현재 적용된 Soft Rule - -위치: `PairingSolverService#createObjective` - -현재 목적함수는 아래 순서가 강하게 반영되도록 가중치를 둡니다. - -1. 배정 센터 수 최대화 -2. 희망지역 매칭 순위가 좋은 후보 선호 -3. 거주지 앞 3자리 일치 페어 선호 - -배정 센터 수가 가장 중요하므로 가장 큰 가중치를 사용합니다. 선호도와 거주지 유사도는 배정 수가 같은 후보들 사이에서 더 나은 해를 고르는 보조 점수입니다. 현재 업무 기준상 거주지 유사도도 중요한 soft rule이지만, 배정 센터 수보다 우선하지는 않습니다. - -## OR-Tools 관련 주요 파일 - -### `build.gradle` - -OR-Tools 의존성을 관리합니다. - -```gradle -implementation("com.google.ortools:ortools-java:9.15.6755") -``` - -OR-Tools 버전을 바꾸면 native library 로딩 방식이나 Java API가 바뀔 수 있으므로 `PairingSolverService` 컴파일과 테스트를 반드시 확인해야 합니다. - -### `OrToolsConfig` - -Spring Boot 기동 시 `Loader.loadNativeLibraries()`를 실행합니다. - -OR-Tools는 Java 라이브러리처럼 보이지만 내부적으로 OS별 native library를 사용합니다. 이 로딩이 빠지면 `UnsatisfiedLinkError`가 발생합니다. - -### `PairingSolverService` - -실제 CP-SAT 모델을 구성합니다. - -수정이 필요한 대표 위치: - -- 변수 추가/변경: `createAssignmentVars`, `createPairUsedVars`, `createPairDayVars` -- hard rule 추가: `add...` 형태의 constraint 메서드 추가 -- soft rule 변경: `createObjective` -- solver 시간 제한 변경: `solver.getParameters().setMaxTimeInSeconds(...)` -- 결과 해석 변경: `collectSelectedAssignments`, `toResult` - -## 결과 엑셀 시트 - -정상 처리 결과는 항상 아래 8개 시트를 포함합니다. - -- `배정결과`: 최종 센터 배정 결과와 위원/센터 주요 속성, AB 보완 페어 정보 -- `미배정센터`: 최종 배정되지 않은 센터와 누적 미배정 사유 -- `미사용위원`: 최종 배정에 포함되지 않은 위원 -- `처리요약`: 전체 입력/후보/배정/AB 그룹 요약 -- `AB페어목록`: 후처리로 묶인 AB 페어 그룹 목록 -- `후보요약`: 후보 생성 및 solver 입력 규모 -- `검증오류`: 정상 처리 시 빈 시트, 입력/검증 오류 엑셀에서는 오류 내용 -- `규칙위반검사`: 결과가 hard rule을 위반하지 않았는지 PASS/FAIL 검사 - -`/run`에서 엑셀 파싱이나 입력 검증 오류가 발생하면 HTTP 200으로 오류 엑셀을 반환합니다. 공휴일 API 실패 같은 시스템 오류는 숨기지 않고 실패 응답으로 처리합니다. - -## 업무 조건 변경 시 수정 위치 - -### 자주 조정될 수 있는 값 - -아래 값들은 `application.yaml`의 `pairing.*` 설정으로 관리합니다. - -```yaml -pairing: - excel: - header-row-index: 1 - code: - region-code-length: 2 - residence-code-length: 5 - residence-match-prefix-length: 3 - any-region-code: "00" - rule: - max-centers-per-pair-per-day: 3 - max-counterparts-per-member: 2 - preference: - anywhere-rank: 0 - ignored-rank: 99 - objective: - assignment-weight: 1000000 - preference-base-weight: 1000 - preference-rank-penalty: 100 - residence-match-weight: 10000 - solver: - max-time-seconds: 30.0 - num-search-workers: 15 -``` - -배정 센터 수 최우선 원칙을 유지하려면 `objective.assignment-weight`가 선호지역, 거주지, 향후 추가될 soft score의 최대 합보다 충분히 커야 합니다. - -### 엑셀 시트명 또는 컬럼명이 바뀌는 경우 - -수정 위치: - -- `PairingConstant` -- `dto.excel.*` -- `PairingExcelService` - -시트명이 바뀌면 `PairingConstant`의 `SHEET_*` 값을 수정합니다. 컬럼명이 바뀌면 해당 `dto.excel` 클래스의 `@ExcelColumn(header = "...")` 값을 수정합니다. - -### 결과 엑셀 시트를 바꾸는 경우 - -수정 위치: - -- `PairingConstant` -- `dto.*ExcelDto` -- `PairingExcelService#write` -- `PairingSolverService#toResult` - -### 지역 코드 자리수가 바뀌는 경우 - -수정 위치: - -- `PairingConstant` -- `PairingNormalizeService` -- `PairingCandidateService` - -현재 활동지역/선호지역은 2자리, 거주지는 5자리, 거주지 비교는 앞 3자리 기준입니다. - -### 선호지역 `00` 규칙이 바뀌는 경우 - -수정 위치: - -- `PairingNormalizeService#normalizePreferenceRegions` -- `PairingCandidateService#findPreferenceRank` - -현재는 `00`이 나오면 그 위치와 뒤쪽 선호지역을 모두 `00`으로 처리합니다. - -### 희망지역 매칭표 해석이 바뀌는 경우 - -수정 위치: - -- `PairingCandidateService#findPreferenceRank` -- `PairingCandidateService#findPreferenceMatchRule` -- `PairingSolverService#createObjective` - -현재는 현장위원 rank와 외부위원 rank를 구한 뒤, 엑셀의 `희망지역 매칭표`에서 매칭 순위를 찾습니다. - -현재 rank 해석: - -- `0`: 위원이 선호지역에 `00`을 입력한 anywhere 응답 -- `99`: 해당 위원의 선호지역을 고려하지 않는 wildcard 조건 - -### 하루 최대 센터 수가 바뀌는 경우 - -수정 위치: - -- `application.yaml`의 `pairing.rule.max-centers-per-pair-per-day` -- `PairingSolverService#addPairDailyCapacity` - -### 한 위원의 상대 파트너 수 제한이 바뀌는 경우 - -수정 위치: - -- `application.yaml`의 `pairing.rule.max-counterparts-per-member` -- `PairingSolverService#addBuddyLimit` - -### 하루 1개 지역 제한 기준이 바뀌는 경우 - -수정 위치: - -- `AssignmentCandidate` -- `PairingCandidateService#createAssignmentCandidates` -- `PairingSolverService#addPairDailyOneAdjacentClassification` - -현재는 `인접지역 분류` 기준입니다. 나중에 권역 단위로 바뀌면 `pairDayAdjacentKey`가 사용하는 값을 바꿔야 합니다. - -### 불가일자 또는 일정 조건이 바뀌는 경우 - -수정 위치: - -- `PairingNormalizeService#parseDateSet` -- `PairingHolidayService` -- `PairingCandidateService#findFirstAssignableDate` -- `PairingCandidateService#isAvailableOn` - -국공휴일 조회 방식이 바뀌면 `PairingHolidayService`와 `DatagoExtentionApiClient`를 함께 확인해야 합니다. -캐시 동작을 바꾸려면 `DatagoHolidayCache`를 확인합니다. - -### 여성 전용 센터 규칙이 바뀌는 경우 - -수정 위치: - -- `PairingNormalizeService#parseBooleanFlag` -- `PairingCandidateService#isAssignableCenter` - -### 2023년 진행 센터 제외 규칙이 바뀌는 경우 - -수정 위치: - -- `PairingNormalizeService#parseCsv` -- `PairingCandidateService#isAssignableCenter` - -### A/B pair 운영 로직을 추가하는 경우 - -수정 위치: - -- `PairingCandidateService` -- `PairingSolverService` -- 필요 시 `model`에 `ABPairCandidate` 추가 - -현재 A/B pair는 solver 결과 후처리로 구성합니다. 같은 파견 권역과 같은 인접지역 분류를 공유하고, 배정 날짜가 겹치지 않는 페어끼리 `AB 그룹`으로 묶습니다. 이는 A/B가 완전 대체 전담 관계가 아니라, 각자 배정은 유지하되 유사시에 서로 공백을 보완할 수 있는 관계라는 업무 해석을 따른 것입니다. - -### 인접지역 분류 랜덤 선택을 엄격하게 적용하는 경우 - -수정 위치: - -- `PairingCandidateService#createAssignmentCandidates` -- `PairingSolverService` -- 별도 후처리 서비스 추가 가능 - -현재 solver는 랜덤 없이 최적 선택을 하며, 같은 날짜/페어에 대해 하나의 인접지역 분류만 선택하도록 hard rule을 걸고 있습니다. 따라서 한 팀이 여러 인접지역 분류 그룹을 갈 수 있는 경우에도 solver가 objective에 가장 유리한 하나의 그룹만 선택합니다. - -## 현재 구현상 주의점 - -- 모든 가능한 날짜를 후보로 만들지 않고, 각 페어/센터 조합의 가장 빠른 feasible 일자만 후보로 만듭니다. -- 이 방식은 후보 수를 줄여 빠르게 동작하지만, 날짜 선택 자유도가 낮아 실제 최적 배정률이 떨어질 수 있습니다. -- 배정률이 부족하면 `PairingCandidateService#findFirstAssignableDate`를 확장해 feasible 일자 여러 개를 후보로 생성해야 합니다. -- A/B pair는 현재 후처리 방식입니다. 배정 자체를 막는 hard constraint가 아니며, 결과 엑셀의 `AB 그룹`, `보완 현장위원 id`, `보완 외부위원 id` 컬럼으로 표시합니다. -- 결과 엑셀은 성공 시 파일로 반환합니다. 입력/검증 오류는 오류 엑셀로 반환하고, 시스템 오류는 공통 `BusinessException` 실패 응답을 사용합니다. +현재 프로젝트에서는 전체 후보가 매우 커질 수 있어 CP-SAT만으로는 시간이 오래 걸릴 수 있습니다. 그래서 주 배정은 Greedy가 담당하고, CP-SAT 코드는 향후 부분 최적화나 비교 실험을 위해 유지합니다. + +CP-SAT 관련 수정 위치: + +| 변경 내용 | 수정 위치 | +| --- | --- | +| 후보 0/1 변수 | `PairingSolverService#createAssignmentVars` | +| 센터 중복 금지 | `PairingSolverService#addCenterAssignedAtMostOnce` | +| 하루 방문 센터 수 | `PairingSolverService#addPairDailyCapacity` | +| 같은 날짜 위원 중복 금지 | `PairingSolverService#addMemberDailyOnePair` | +| 인접지역 분류 제한 | `PairingSolverService#addPairDailyOneAdjacentClassification` | +| 상대 파트너 수 제한 | `PairingSolverService#addCumulativeBuddyLimit` | +| 점수 조정 | `PairingSolverService#createObjective` | + +## 규칙 변경 시 수정 위치 + +| 업무 변경 | 수정 위치 | +| --- | --- | +| 엑셀 시트명 변경 | `PairingConstant` | +| 엑셀 컬럼명 변경 | `dto.excel.input`, `dto.excel.output`의 `@ExcelColumn` | +| 입력 정규화 변경 | `PairingNormalizeService` | +| 공휴일/주말 정책 변경 | `PairingHolidayService`, `DatagoHolidayCache` | +| 상피제 변경 | `PairingCandidateService#isConflictRegion`, `hasActivityRegion` | +| 여성전용센터 정책 변경 | `PairingCandidateService#findCenterHardRuleReasons` | +| 기방문센터 제외 정책 변경 | `PairingCandidateService#findCenterHardRuleReasons` | +| 희망지역 00/99 해석 변경 | `PairingCandidateService#findPreferenceRank`, `findPreferenceMatchRule`, `matchesPreferenceRank` | +| wildcard 적극 사용 롤백 | `application.yaml`의 `active-wildcard-fallback-enabled: false` | +| 위원당 상대 파트너 수 변경 | `application.yaml`의 `max-counterparts-per-member` | +| 하루 센터 방문 수 변경 | `application.yaml`의 `max-centers-per-pair-per-day` | +| 위원 최대 방문 상한 변경 | `application.yaml`의 `max-member-visit-average-ratio-percent` | +| 배정 점수 튜닝 | `application.yaml`의 `objective.*` | +| repair 전략 변경 | `PairingScheduleService`의 `repair...` 메서드 | ## 테스트 +컴파일: + +```powershell +.\gradlew.bat compileJava +``` + 전체 테스트: ```powershell -.\gradlew.bat clean test +.\gradlew.bat test ``` -샘플 엑셀 전체 흐름 테스트: +샘플 엑셀 기반 테스트: ```powershell -.\gradlew.bat test --tests "com.kri.p6.ncrc.pairing.service.PairingServiceTest.pairingMemberByCenterCreatesResultWorkbook" +.\gradlew.bat test --tests com.kri.p6.ncrc.pairing.service.PairingServiceTest ``` -실제 API 실행 테스트: - -```powershell -.\gradlew.bat bootJar -java -jar build/libs/ncrc-pairing-0.0.1-SNAPSHOT.jar -curl.exe -X POST "http://localhost:6111/api/v1/pairing/run" -F "file=@src/main/resources/sample/기초 data dummy.xlsx" -o build/api-result.xlsx -``` +결과 파일은 테스트 실행 시 `build/pairing-result*.xlsx`로 생성됩니다. diff --git a/build.gradle b/build.gradle index c98f249..7b8d8e8 100644 --- a/build.gradle +++ b/build.gradle @@ -68,5 +68,5 @@ dependencies { tasks.named('test') { useJUnitPlatform() - maxHeapSize = '4g' + maxHeapSize = '8g' } diff --git a/src/main/java/com/kri/p6/ncrc/pairing/common/consts/PairingConstant.java b/src/main/java/com/kri/p6/ncrc/pairing/common/consts/PairingConstant.java index e8022e1..0aba631 100644 --- a/src/main/java/com/kri/p6/ncrc/pairing/common/consts/PairingConstant.java +++ b/src/main/java/com/kri/p6/ncrc/pairing/common/consts/PairingConstant.java @@ -18,6 +18,8 @@ public final class PairingConstant { public static final String RESULT_SHEET_VALIDATION_ERROR = "검증오류"; public static final String RESULT_SHEET_RULE_CHECK = "규칙위반검사"; + public static final String RESULT_SHEET_APPLIED_SETTING = "적용설정"; + private PairingConstant() { } } diff --git a/src/main/java/com/kri/p6/ncrc/pairing/config/PairingProperties.java b/src/main/java/com/kri/p6/ncrc/pairing/config/PairingProperties.java index 53d5ca7..bc0687c 100644 --- a/src/main/java/com/kri/p6/ncrc/pairing/config/PairingProperties.java +++ b/src/main/java/com/kri/p6/ncrc/pairing/config/PairingProperties.java @@ -36,7 +36,8 @@ public class PairingProperties { @Setter public static class Rule { private int maxCentersPerPairPerDay = 3; - private int maxCounterpartsPerMember = 2; + private int maxCounterpartsPerMember = 3; + private int maxMemberVisitAverageRatioPercent = 130; } @Getter @@ -44,26 +45,28 @@ public class PairingProperties { public static class Preference { private int anywhereRank = 0; private int ignoredRank = 99; + private boolean activeWildcardFallbackEnabled = false; + private long wildcardFallbackScoreBonus = 25_000L; } @Getter @Setter public static class Objective { private long assignmentWeight = 1_000_000L; - private long preferenceBaseWeight = 10_000L; - private long preferenceRankPenalty = 100L; - private long residenceMatchWeight = 1_000L; - private long usedMemberWeight = 300_000L; - private long memberBalanceWeight = 1_000L; + private long preferenceBaseWeight = 30_000L; + private long preferenceRankPenalty = 1_000L; + private long residenceMatchWeight = 10_000L; + private long memberBalanceWeight = 20_000L; } @Getter @Setter public static class Candidate { - private int maxDispatchRegionsPerPair = 5; - private int maxAssignmentsPerCenter = 30; - private int maxAssignmentsPerMember = 80; - private int maxDatesPerAssignmentCandidate = 5; + private int maxPairCandidatesPerMember = 0; + private int maxDispatchRegionsPerPair = 0; + private int maxAssignmentsPerCenter = 1_000; + private int maxAssignmentsPerMember = 3_000; + private int maxDatesPerAssignmentCandidate = 80; } @Getter diff --git a/src/main/java/com/kri/p6/ncrc/pairing/dto/excel/output/AppliedSettingExcelDto.java b/src/main/java/com/kri/p6/ncrc/pairing/dto/excel/output/AppliedSettingExcelDto.java new file mode 100644 index 0000000..b38b190 --- /dev/null +++ b/src/main/java/com/kri/p6/ncrc/pairing/dto/excel/output/AppliedSettingExcelDto.java @@ -0,0 +1,21 @@ +package com.kri.p6.ncrc.pairing.dto.excel.output; + +import com.kri.common.feature.excel.ExcelColumn; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +@Data +@NoArgsConstructor +@AllArgsConstructor +public class AppliedSettingExcelDto { + + @ExcelColumn(header = "설정명", order = 0, width = 38) + private String name; + + @ExcelColumn(header = "설정에 대한 설명", order = 1, width = 70) + private String description; + + @ExcelColumn(header = "값", order = 2, width = 24) + private String value; +} diff --git a/src/main/java/com/kri/p6/ncrc/pairing/model/PairingResult.java b/src/main/java/com/kri/p6/ncrc/pairing/model/PairingResult.java index f49e8fb..7737d98 100644 --- a/src/main/java/com/kri/p6/ncrc/pairing/model/PairingResult.java +++ b/src/main/java/com/kri/p6/ncrc/pairing/model/PairingResult.java @@ -1,6 +1,7 @@ package com.kri.p6.ncrc.pairing.model; import com.kri.p6.ncrc.pairing.dto.excel.output.ABPairExcelDto; +import com.kri.p6.ncrc.pairing.dto.excel.output.AppliedSettingExcelDto; import com.kri.p6.ncrc.pairing.dto.excel.output.AssignmentResultExcelDto; import com.kri.p6.ncrc.pairing.dto.excel.output.CandidateSummaryExcelDto; import com.kri.p6.ncrc.pairing.dto.excel.output.PairingSummaryExcelDto; @@ -22,6 +23,7 @@ public class PairingResult { private final List summaries; private final List abPairs; private final List candidateSummaries; + private final List appliedSettings; private final List validationErrors; private final List ruleViolations; diff --git a/src/main/java/com/kri/p6/ncrc/pairing/service/PairingCandidateService.java b/src/main/java/com/kri/p6/ncrc/pairing/service/PairingCandidateService.java index 33da1ba..5313ede 100644 --- a/src/main/java/com/kri/p6/ncrc/pairing/service/PairingCandidateService.java +++ b/src/main/java/com/kri/p6/ncrc/pairing/service/PairingCandidateService.java @@ -22,6 +22,7 @@ import java.util.LinkedHashSet; import java.util.List; import java.util.Map; import java.util.Optional; +import java.util.PriorityQueue; import java.util.Set; import java.util.function.Function; import java.util.stream.Collectors; @@ -35,7 +36,10 @@ public class PairingCandidateService { private final PairingProperties pairingProperties; public PairingCandidates generate(PairingData data) { - List pairCandidates = createPairCandidates(data.getMembers()); + // 후보 생성은 "가능한 조합을 넓게 만들고, 명백히 불가능한 조합만 제거"하는 단계입니다. + // 이후 PairingScheduleService가 이 후보들 중 실제 방문 일정을 선택합니다. + List pairCandidates = trimPairCandidates( + createPairCandidates(data.getMembers()), data.getMembers()); List dispatchRegionCandidates = trimDispatchRegionCandidates( createDispatchRegionCandidates(data, pairCandidates)); Map> unassignedCenterReasons = createInitialCenterReasonMap(data); @@ -53,6 +57,8 @@ public class PairingCandidateService { } private List createPairCandidates(List members) { + // 현장위원 1명 + 외부위원 1명을 기본 조로 봅니다. + // 두 위원의 활동 가능 기간이 전혀 겹치지 않으면 이후 센터 배정이 불가능하므로 제외합니다. List fieldMembers = members.stream() .filter(member -> member.getRole() == MemberRole.FIELD).toList(); List externalMembers = members.stream() @@ -75,6 +81,8 @@ public class PairingCandidateService { private List createDispatchRegionCandidates(PairingData data, List pairCandidates) { + // 조가 갈 수 있는 파견 권역 후보를 만듭니다. + // 상피제(위원 활동지역과 파견 권역 일치)는 여기서 제거합니다. Map memberMap = toMemberMap(data.getMembers()); Set dispatchRegions = data.getCenterAdjacentRegions().stream() .map(CenterAdjacentRegion::getDispatchRegion).collect(Collectors.toSet()); @@ -92,6 +100,8 @@ public class PairingCandidateService { Optional matchRule = findPreferenceMatchRule( data.getPreferenceMatchRules(), fieldRank, externalRank); + // fieldRank/externalRank가 -1이어도 희망지역 매칭표의 99(wildcard) 규칙은 적용될 수 있습니다. + // 99는 "해당 위원의 희망지역을 고려하지 않음"이라는 후순위 fallback입니다. candidates.add(DispatchRegionCandidate.builder().fieldMemberId(fieldMember.getId()) .externalMemberId(externalMember.getId()).dispatchRegion(dispatchRegion) .preferencePriority(matchRule.map(PreferenceMatchRule::getPriority) @@ -111,6 +121,8 @@ public class PairingCandidateService { List dispatchRegionCandidates, Map> unassignedCenterReasons ) { + // 파견 권역 후보를 실제 센터와 날짜 후보로 확장합니다. + // 여성전용, 기방문센터, 위원/지자체/센터 불가능일, 공휴일/주말은 이 단계에서 제외합니다. Map memberMap = toMemberMap(data.getMembers()); Map municipalityMap = data.getMunicipalities().stream() .collect(Collectors.toMap(Municipality::getId, Function.identity(), (left, right) -> left)); @@ -120,8 +132,13 @@ public class PairingCandidateService { .stream().collect(Collectors.groupingBy(CenterAdjacentRegion::getDispatchRegion, Collectors.mapping(CenterAdjacentRegion::getAdjacentRegionClassification, Collectors.toSet()))); + Map> centersByAdjacentClassification = data.getCenters().stream() + .collect(Collectors.groupingBy(Center::getAdjacentRegionClassification, + LinkedHashMap::new, Collectors.toList())); + Set commonUnavailableDates = commonUnavailableDates(data); - List candidates = new ArrayList<>(); + Map> centerCandidateBuckets = new LinkedHashMap<>(); + Map> memberCandidateBuckets = new LinkedHashMap<>(); for (DispatchRegionCandidate dispatchCandidate : dispatchRegionCandidates) { Member fieldMember = memberMap.get(dispatchCandidate.getFieldMemberId()); @@ -132,7 +149,8 @@ public class PairingCandidateService { Set adjacentClassifications = adjacentClassificationsByDispatchRegion .getOrDefault(dispatchCandidate.getDispatchRegion(), Set.of()); - for (Center center : data.getCenters()) { + for (Center center : centersForDispatch(adjacentClassifications, + centersByAdjacentClassification)) { if (!adjacentClassifications.contains(center.getAdjacentRegionClassification())) { addReason(unassignedCenterReasons, center.getId(), "파견 권역과 센터 인접지역 분류 불일치"); } else { @@ -145,13 +163,14 @@ public class PairingCandidateService { reason -> addReason(unassignedCenterReasons, center.getId(), reason)); } else { List assignableDates = findAssignableDates(fieldMember, - externalMember, municipality, center, commonUnavailableDates(data)); + externalMember, municipality, center, commonUnavailableDates); if (assignableDates.isEmpty()) { addReason(unassignedCenterReasons, center.getId(), "위원/지자체/센터 일정 또는 국공휴일 조건 불일치"); } else { for (LocalDate assignableDate : assignableDates) { - candidates.add(AssignmentCandidate.builder().fieldMemberId(fieldMember.getId()) + addBoundedAssignmentCandidate(centerCandidateBuckets, memberCandidateBuckets, + AssignmentCandidate.builder().fieldMemberId(fieldMember.getId()) .externalMemberId(externalMember.getId()).centerId(center.getId()) .municipalityId(center.getMunicipalityId()).date(assignableDate) .dispatchRegion(dispatchCandidate.getDispatchRegion()) @@ -168,7 +187,7 @@ public class PairingCandidateService { } } - return candidates; + return mergeAssignmentCandidateBuckets(centerCandidateBuckets, memberCandidateBuckets); } private List preferResidenceMatchesByCenter( @@ -195,6 +214,116 @@ public class PairingCandidateService { .toList(); } + private List trimPairCandidates(List candidates, + List members) { + int limit = maxPairCandidatesPerMember(); + if (limit <= 0) { + return candidates; + } + + Map memberMap = toMemberMap(members); + Map memberUsage = new HashMap<>(); + List selected = new ArrayList<>(); + Set selectedKeys = new LinkedHashSet<>(); + + for (PairCandidate candidate : candidates.stream() + .sorted(pairCandidateComparator(memberMap)) + .toList()) { + int fieldCount = memberUsage.getOrDefault(candidate.getFieldMemberId(), 0); + int externalCount = memberUsage.getOrDefault(candidate.getExternalMemberId(), 0); + if (fieldCount < limit && externalCount < limit) { + addPairCandidate(selected, selectedKeys, memberUsage, candidate); + } + } + + Set missingMemberIds = candidates.stream() + .flatMap(candidate -> java.util.stream.Stream.of(candidate.getFieldMemberId(), + candidate.getExternalMemberId())) + .filter(memberId -> memberUsage.getOrDefault(memberId, 0) == 0) + .collect(Collectors.toCollection(LinkedHashSet::new)); + + for (PairCandidate candidate : candidates.stream() + .sorted(pairCandidateComparator(memberMap)) + .toList()) { + if (missingMemberIds.isEmpty()) { + break; + } + if (selectedKeys.contains(pairKey(candidate))) { + continue; + } + if (!missingMemberIds.contains(candidate.getFieldMemberId()) + && !missingMemberIds.contains(candidate.getExternalMemberId())) { + continue; + } + + addPairCandidate(selected, selectedKeys, memberUsage, candidate); + missingMemberIds.remove(candidate.getFieldMemberId()); + missingMemberIds.remove(candidate.getExternalMemberId()); + } + + return selected; + } + + private void addPairCandidate(List selected, Set selectedKeys, + Map memberUsage, PairCandidate candidate) { + selected.add(candidate); + selectedKeys.add(pairKey(candidate)); + memberUsage.merge(candidate.getFieldMemberId(), 1, Integer::sum); + memberUsage.merge(candidate.getExternalMemberId(), 1, Integer::sum); + } + + private List
centersForDispatch(Set adjacentClassifications, + Map> centersByAdjacentClassification) { + return adjacentClassifications.stream() + .flatMap(adjacentClassification -> centersByAdjacentClassification + .getOrDefault(adjacentClassification, List.of()).stream()) + .toList(); + } + + private void addBoundedAssignmentCandidate( + Map> centerCandidateBuckets, + Map> memberCandidateBuckets, + AssignmentCandidate candidate) { + // 후보 수가 너무 커지면 처리 시간이 급격히 늘어납니다. + // 센터별/위원별 후보 상한을 두되, 0이면 제한하지 않습니다. + addBounded(centerCandidateBuckets, candidate.getCenterId(), candidate, + maxAssignmentsPerCenter()); + addBounded(memberCandidateBuckets, candidate.getFieldMemberId(), candidate, + maxAssignmentsPerMember()); + addBounded(memberCandidateBuckets, candidate.getExternalMemberId(), candidate, + maxAssignmentsPerMember()); + } + + private void addBounded(Map> buckets, String key, + AssignmentCandidate candidate, int limit) { + PriorityQueue bucket = buckets.computeIfAbsent(key, + ignored -> new PriorityQueue<>(worstAssignmentComparator())); + if (limit <= 0 || bucket.size() < limit) { + bucket.add(candidate); + return; + } + + AssignmentCandidate worstCandidate = bucket.peek(); + if (worstCandidate != null + && assignmentCandidateComparator().compare(candidate, worstCandidate) < 0) { + bucket.poll(); + bucket.add(candidate); + } + } + + private List mergeAssignmentCandidateBuckets( + Map> centerCandidateBuckets, + Map> memberCandidateBuckets) { + Map merged = new LinkedHashMap<>(); + centerCandidateBuckets.values().forEach(bucket -> bucket.forEach(candidate -> + merged.putIfAbsent(assignmentKey(candidate), candidate))); + memberCandidateBuckets.values().forEach(bucket -> bucket.forEach(candidate -> + merged.putIfAbsent(assignmentKey(candidate), candidate))); + return merged.values().stream() + .sorted(assignmentCandidateComparator()) + .toList(); + } + private List trimAssignmentCandidates(List candidates, List
centers, Map> unassignedCenterReasons) { List trimmedByCenter = trimAssignmentsPerCenter(candidates); @@ -375,13 +504,14 @@ public class PairingCandidateService { private Optional findPreferenceMatchRule(List rules, int fieldRank, int externalRank) { - return fieldRank >= 0 && externalRank >= 0 ? - rules.stream().filter( + // 99 규칙은 wildcard입니다. 예를 들어 fieldRank가 -1이어도 + // 매칭표에 99/1 규칙이 있으면 "현장위원 선호지역 고려하지 않음 + 외부위원 1순위"로 인정합니다. + return rules.stream().filter( rule -> matchesPreferenceRank(rule.getFieldMemberPreferenceRank(), fieldRank) ) - .filter(rule -> matchesPreferenceRank(rule.getExternalMemberPreferenceRank(),externalRank)) + .filter(rule -> matchesPreferenceRank(rule.getExternalMemberPreferenceRank(), externalRank)) .min(Comparator.comparingInt(PreferenceMatchRule::getPriority)) - : Optional.empty(); + ; } private int fallbackPreferencePriority(List rules) { @@ -425,14 +555,30 @@ public class PairingCandidateService { if (isAvailableOn(date, fieldMember, externalMember, municipality, center, commonUnavailableDates)) { dates.add(date); - if (dates.size() >= maxDatesPerAssignmentCandidate()) { - break; - } } } } - return dates; + return spreadDates(dates, maxDatesPerAssignmentCandidate()); + } + + private List spreadDates(List dates, int limit) { + if (limit <= 0 || dates.size() <= limit) { + return dates; + } + if (limit == 1) { + return List.of(dates.get(0)); + } + + List spread = new ArrayList<>(); + for (int i = 0; i < limit; i++) { + int index = (int) Math.round((double) i * (dates.size() - 1) / (limit - 1)); + LocalDate date = dates.get(index); + if (!spread.contains(date)) { + spread.add(date); + } + } + return spread; } private boolean isAvailableOn(LocalDate date, Member fieldMember, Member externalMember, @@ -520,10 +666,22 @@ public class PairingCandidateService { return pairingProperties.getCandidate().getMaxAssignmentsPerMember(); } + private int maxPairCandidatesPerMember() { + return pairingProperties.getCandidate().getMaxPairCandidatesPerMember(); + } + private int maxDatesPerAssignmentCandidate() { return pairingProperties.getCandidate().getMaxDatesPerAssignmentCandidate(); } + private Comparator pairCandidateComparator(Map memberMap) { + return Comparator.comparingInt((PairCandidate candidate) -> pairCandidateScore(candidate, + memberMap)) + .reversed() + .thenComparing(PairCandidate::getFieldMemberId) + .thenComparing(PairCandidate::getExternalMemberId); + } + private Comparator dispatchRegionCandidateComparator() { return Comparator.comparingInt(this::dispatchRegionCandidateScore).reversed() .thenComparing(DispatchRegionCandidate::getDispatchRegion); @@ -537,20 +695,72 @@ public class PairingCandidateService { .thenComparing(AssignmentCandidate::getExternalMemberId); } + private Comparator worstAssignmentComparator() { + return Comparator.comparingInt(this::assignmentCandidateScore) + .thenComparing(AssignmentCandidate::getDate, Comparator.reverseOrder()) + .thenComparing(AssignmentCandidate::getCenterId, Comparator.reverseOrder()) + .thenComparing(AssignmentCandidate::getFieldMemberId, Comparator.reverseOrder()) + .thenComparing(AssignmentCandidate::getExternalMemberId, Comparator.reverseOrder()); + } + private int dispatchRegionCandidateScore(DispatchRegionCandidate candidate) { return preferenceScore(candidate.getPreferencePriority()) + preferenceRankBonus(candidate.getFieldMemberPreferenceRank()) + preferenceRankBonus(candidate.getExternalMemberPreferenceRank()); } + private int pairCandidateScore(PairCandidate candidate, Map memberMap) { + Member fieldMember = memberMap.get(candidate.getFieldMemberId()); + Member externalMember = memberMap.get(candidate.getExternalMemberId()); + return preferenceIntersectionScore(fieldMember, externalMember) + + candidate.getResidenceMatchScore() * 10; + } + + private int preferenceIntersectionScore(Member fieldMember, Member externalMember) { + if (fieldMember == null || externalMember == null) { + return 0; + } + + Set externalPreferences = new LinkedHashSet<>(externalMember.getPreferenceRegions()); + int score = 0; + for (String preference : fieldMember.getPreferenceRegions()) { + if (ignoredPreferenceCode(preference)) { + continue; + } + if (anyRegionCode().equals(preference) && externalPreferences.contains(preference)) { + score += 10; + } else if (externalPreferences.contains(preference)) { + score += 100; + } + } + return score; + } + + private boolean ignoredPreferenceCode(String preference) { + return String.valueOf(ignoredPreferenceRank()).equals(preference); + } + private int assignmentCandidateScore(AssignmentCandidate candidate) { return preferenceScore(candidate.getPreferencePriority()) + preferenceRankBonus(candidate.getFieldMemberPreferenceRank()) + preferenceRankBonus(candidate.getExternalMemberPreferenceRank()) + + wildcardFallbackBonus(candidate) + candidate.getResidenceMatchScore() * (int) pairingProperties.getObjective() .getResidenceMatchWeight(); } + private int wildcardFallbackBonus(AssignmentCandidate candidate) { + // wildcard 적극 사용 옵션입니다. true이면 99 규칙으로 살아난 후보가 + // 후보 축소 단계에서 너무 쉽게 밀려나지 않도록 보너스를 줍니다. + if (!activeWildcardFallbackEnabled()) { + return 0; + } + if (!usesWildcardFallback(candidate)) { + return 0; + } + return (int) Math.min(Integer.MAX_VALUE, wildcardFallbackScoreBonus()); + } + private int preferenceScore(int priority) { return (int) Math.max(0L, pairingProperties.getObjective().getPreferenceBaseWeight() - priority * pairingProperties.getObjective().getPreferenceRankPenalty()); @@ -568,6 +778,19 @@ public class PairingCandidateService { return Math.max(0, 10 - rank); } + private boolean usesWildcardFallback(AssignmentCandidate candidate) { + return candidate.getFieldMemberPreferenceRank() < 0 + || candidate.getExternalMemberPreferenceRank() < 0; + } + + private boolean activeWildcardFallbackEnabled() { + return pairingProperties.getPreference().isActiveWildcardFallbackEnabled(); + } + + private long wildcardFallbackScoreBonus() { + return pairingProperties.getPreference().getWildcardFallbackScoreBonus(); + } + private LocalDate max(LocalDate left, LocalDate right) { return left.isAfter(right) ? left : right; } diff --git a/src/main/java/com/kri/p6/ncrc/pairing/service/PairingExcelService.java b/src/main/java/com/kri/p6/ncrc/pairing/service/PairingExcelService.java index 94e128a..a467b7a 100644 --- a/src/main/java/com/kri/p6/ncrc/pairing/service/PairingExcelService.java +++ b/src/main/java/com/kri/p6/ncrc/pairing/service/PairingExcelService.java @@ -1,6 +1,7 @@ package com.kri.p6.ncrc.pairing.service; import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_AB_PAIR; +import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_APPLIED_SETTING; import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_ASSIGNMENT; import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_CANDIDATE_SUMMARY; import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_RULE_CHECK; @@ -26,6 +27,7 @@ import com.kri.p6.ncrc.pairing.dto.excel.input.MunicipalityExcelDto; import com.kri.p6.ncrc.pairing.dto.excel.input.PairingWorkbookData; import com.kri.p6.ncrc.pairing.dto.excel.input.PreferenceMatchExcelDto; import com.kri.p6.ncrc.pairing.dto.excel.output.ABPairExcelDto; +import com.kri.p6.ncrc.pairing.dto.excel.output.AppliedSettingExcelDto; import com.kri.p6.ncrc.pairing.dto.excel.output.AssignmentResultExcelDto; import com.kri.p6.ncrc.pairing.dto.excel.output.CandidateSummaryExcelDto; import com.kri.p6.ncrc.pairing.dto.excel.output.PairingSummaryExcelDto; @@ -93,6 +95,8 @@ public class PairingExcelService { RESULT_SHEET_AB_PAIR, headerRowIndex()); ExcelMapper.appendSheetToWorkbook(workbook, result.getCandidateSummaries(), CandidateSummaryExcelDto.class, RESULT_SHEET_CANDIDATE_SUMMARY, headerRowIndex()); + ExcelMapper.appendSheetToWorkbook(workbook, result.getAppliedSettings(), + AppliedSettingExcelDto.class, RESULT_SHEET_APPLIED_SETTING, headerRowIndex()); ExcelMapper.appendSheetToWorkbook(workbook, result.getValidationErrors(), ValidationErrorExcelDto.class, RESULT_SHEET_VALIDATION_ERROR, headerRowIndex()); ExcelMapper.appendSheetToWorkbook(workbook, result.getRuleViolations(), @@ -114,6 +118,7 @@ public class PairingExcelService { .summaries(List.of(new PairingSummaryExcelDto("처리 상태", "검증 실패"))) .abPairs(List.of()) .candidateSummaries(List.of()) + .appliedSettings(appliedSettings()) .validationErrors(List.of(new ValidationErrorExcelDto(code, message, "ERROR"))) .ruleViolations(List.of()) .build(); @@ -135,6 +140,93 @@ public class PairingExcelService { return pairingProperties.getExcel().getHeaderRowIndex(); } + private List appliedSettings() { + PairingProperties.Excel excel = pairingProperties.getExcel(); + PairingProperties.Code code = pairingProperties.getCode(); + PairingProperties.Rule rule = pairingProperties.getRule(); + PairingProperties.Preference preference = pairingProperties.getPreference(); + PairingProperties.Objective objective = pairingProperties.getObjective(); + PairingProperties.Candidate candidate = pairingProperties.getCandidate(); + PairingProperties.Solver solver = pairingProperties.getSolver(); + return List.of( + setting("pairing.excel.header-row-index", + "엑셀 헤더로 사용할 행 인덱스", + excel.getHeaderRowIndex()), + setting("pairing.code.region-code-length", + "지역코드 정규화 길이", code.getRegionCodeLength()), + setting("pairing.code.residence-code-length", + "거주지코드 정규화 길이", + code.getResidenceCodeLength()), + setting("pairing.code.residence-match-prefix-length", + "거주지 일치 판단에 사용하는 앞자리 길이", + code.getResidenceMatchPrefixLength()), + setting("pairing.code.any-region-code", + "희망지역 anywhere로 처리하는 코드", + code.getAnyRegionCode()), + setting("pairing.rule.max-centers-per-pair-per-day", + "같은 페어가 하루에 방문할 수 있는 최대 센터 수", + rule.getMaxCentersPerPairPerDay()), + setting("pairing.rule.max-counterparts-per-member", + "위원 1명당 허용되는 상대 위원 최대 수", + rule.getMaxCounterpartsPerMember()), + setting("pairing.rule.max-member-visit-average-ratio-percent", + "위원별 방문 수 상한을 평균 대비 몇 %까지 허용할지", + rule.getMaxMemberVisitAverageRatioPercent()), + setting("pairing.preference.anywhere-rank", + "선호지역 anywhere를 의미하는 순위", + preference.getAnywhereRank()), + setting("pairing.preference.ignored-rank", + "선호지역 고려하지 않음을 의미하는 순위", + preference.getIgnoredRank()), + setting("pairing.preference.active-wildcard-fallback-enabled", + "희망지역 고려하지 않음을 wildcard로 적극 사용할지", + preference.isActiveWildcardFallbackEnabled()), + setting("pairing.preference.wildcard-fallback-score-bonus", + "wildcard 후보에 추가할 점수", + preference.getWildcardFallbackScoreBonus()), + setting("pairing.objective.assignment-weight", + "센터 하나를 더 배정하는 것에 부여하는 기본 점수", + objective.getAssignmentWeight()), + setting("pairing.objective.preference-base-weight", + "희망지역 매칭 품질에 부여하는 기본 점수", + objective.getPreferenceBaseWeight()), + setting("pairing.objective.preference-rank-penalty", + "희망순위가 낮아질 때 감점하는 점수", + objective.getPreferenceRankPenalty()), + setting("pairing.objective.residence-match-weight", + "거주지 유사도 점수에 곱하는 가중치", + objective.getResidenceMatchWeight()), + setting("pairing.objective.member-balance-weight", + "방문 수가 많은 위원을 더 선택하지 않도록 감점하는 가중치", + objective.getMemberBalanceWeight()), + setting("pairing.candidate.max-pair-candidates-per-member", + "위원별 페어 후보 축소 상한, 0이면 무제한", + candidate.getMaxPairCandidatesPerMember()), + setting("pairing.candidate.max-dispatch-regions-per-pair", + "페어별 파견 권역 후보 축소 상한, 0이면 무제한", + candidate.getMaxDispatchRegionsPerPair()), + setting("pairing.candidate.max-assignments-per-center", + "센터별 배정 후보 축소 상한", + candidate.getMaxAssignmentsPerCenter()), + setting("pairing.candidate.max-assignments-per-member", + "위원별 배정 후보 축소 상한", + candidate.getMaxAssignmentsPerMember()), + setting("pairing.candidate.max-dates-per-assignment-candidate", + "하나의 페어-센터 조합에서 확장할 날짜 후보 상한", + candidate.getMaxDatesPerAssignmentCandidate()), + setting("pairing.solver.max-time-seconds", + "CP-SAT 사용 시 허용할 최대 탐색 시간", + solver.getMaxTimeSeconds()), + setting("pairing.solver.num-search-workers", + "CP-SAT 사용 시 사용할 worker 수", + solver.getNumSearchWorkers()) + ); + } + + private AppliedSettingExcelDto setting(String name, String description, Object value) { + return new AppliedSettingExcelDto(name, description, String.valueOf(value)); + } + private boolean isBlankRow(Object row) { return Arrays.stream(row.getClass().getDeclaredFields()) .allMatch(field -> isBlankField(row, field)); diff --git a/src/main/java/com/kri/p6/ncrc/pairing/service/PairingMemberPairService.java b/src/main/java/com/kri/p6/ncrc/pairing/service/PairingMemberPairService.java new file mode 100644 index 0000000..d2154d4 --- /dev/null +++ b/src/main/java/com/kri/p6/ncrc/pairing/service/PairingMemberPairService.java @@ -0,0 +1,140 @@ +package com.kri.p6.ncrc.pairing.service; + +import com.kri.p6.ncrc.pairing.config.PairingProperties; +import com.kri.p6.ncrc.pairing.model.Member; +import com.kri.p6.ncrc.pairing.model.PairCandidate; +import com.kri.p6.ncrc.pairing.model.PairingData; +import java.util.ArrayList; +import java.util.Comparator; +import java.util.HashMap; +import java.util.HashSet; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.stream.Collectors; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Service; + +@Service +@RequiredArgsConstructor +public class PairingMemberPairService { + + private final PairingProperties pairingProperties; + + public PairSelection select(PairingData data, List pairCandidates) { + return select(data, pairCandidates, Map.of()); + } + + public PairSelection select(PairingData data, List pairCandidates, + Map assignmentCountByPair) { + // 0순위 전제: 모든 위원은 최소 1개 이상의 조에 포함되어야 합니다. + // 그래서 센터 배정 전에 먼저 조편성만 수행합니다. + Set allMemberIds = data.getMembers().stream() + .map(Member::getId) + .collect(Collectors.toCollection(LinkedHashSet::new)); + Map> counterpartsByMember = createCounterpartMap(allMemberIds); + List selectedPairs = new ArrayList<>(); + List sortedCandidates = pairCandidates.stream() + .sorted(pairComparator(assignmentCountByPair)) + .toList(); + + boolean changed; + do { + // 아직 조가 없는 위원을 우선 포함시키는 greedy 방식입니다. + // assignmentCountByPair가 큰 조는 실제 센터 후보가 많다는 뜻이므로 먼저 선택합니다. + changed = false; + Set unmatchedMemberIds = unmatchedMemberIds(allMemberIds, counterpartsByMember); + for (PairCandidate candidate : sortedCandidates) { + if (unmatchedMemberIds.isEmpty()) { + break; + } + if (!coversUnmatchedMember(candidate, unmatchedMemberIds)) { + continue; + } + if (!canAddPair(candidate, counterpartsByMember)) { + continue; + } + + addPair(selectedPairs, counterpartsByMember, candidate); + unmatchedMemberIds.remove(candidate.getFieldMemberId()); + unmatchedMemberIds.remove(candidate.getExternalMemberId()); + changed = true; + } + } while (changed && !unmatchedMemberIds(allMemberIds, counterpartsByMember).isEmpty()); + + Set unmatchedMemberIds = unmatchedMemberIds(allMemberIds, counterpartsByMember); + if (!unmatchedMemberIds.isEmpty()) { + return new PairSelection(false, selectedPairs, + "페어링되지 않은 위원이 있습니다: " + String.join(", ", unmatchedMemberIds)); + } + + selectedPairs.sort(Comparator.comparing(PairCandidate::getFieldMemberId) + .thenComparing(PairCandidate::getExternalMemberId)); + return new PairSelection(true, selectedPairs, "GREEDY_PAIRED"); + } + + private Map> createCounterpartMap(Set memberIds) { + Map> counterpartsByMember = new HashMap<>(); + memberIds.forEach(memberId -> counterpartsByMember.put(memberId, new HashSet<>())); + return counterpartsByMember; + } + + private Set unmatchedMemberIds(Set allMemberIds, + Map> counterpartsByMember) { + return allMemberIds.stream() + .filter(memberId -> counterpartsByMember.getOrDefault(memberId, Set.of()).isEmpty()) + .collect(Collectors.toCollection(LinkedHashSet::new)); + } + + private boolean coversUnmatchedMember(PairCandidate candidate, Set unmatchedMemberIds) { + return unmatchedMemberIds.contains(candidate.getFieldMemberId()) + || unmatchedMemberIds.contains(candidate.getExternalMemberId()); + } + + private boolean canAddPair(PairCandidate candidate, + Map> counterpartsByMember) { + if (counterpartsByMember.get(candidate.getFieldMemberId()) + .contains(candidate.getExternalMemberId())) { + return false; + } + return counterpartsByMember.get(candidate.getFieldMemberId()).size() < maxCounterpartsPerMember() + && counterpartsByMember.get(candidate.getExternalMemberId()).size() + < maxCounterpartsPerMember(); + } + + private void addPair(List selectedPairs, + Map> counterpartsByMember, PairCandidate candidate) { + selectedPairs.add(candidate); + counterpartsByMember.get(candidate.getFieldMemberId()).add(candidate.getExternalMemberId()); + counterpartsByMember.get(candidate.getExternalMemberId()).add(candidate.getFieldMemberId()); + } + + private Comparator pairComparator(Map assignmentCountByPair) { + // 1순위: 해당 조가 갈 수 있는 센터/날짜 후보 수 + // 2순위: 거주지 유사도 + // 이후 id 정렬은 같은 점수일 때 결과가 매번 흔들리지 않게 하기 위한 tie-breaker입니다. + return Comparator.comparingLong((PairCandidate candidate) -> + assignmentCountByPair.getOrDefault(pairKey(candidate), 0L)) + .reversed() + .thenComparing(Comparator.comparingInt(this::unmatchedPairScore).reversed()) + .thenComparing(PairCandidate::getFieldMemberId) + .thenComparing(PairCandidate::getExternalMemberId); + } + + private int unmatchedPairScore(PairCandidate candidate) { + return candidate.getResidenceMatchScore(); + } + + private int maxCounterpartsPerMember() { + return pairingProperties.getRule().getMaxCounterpartsPerMember(); + } + + private String pairKey(PairCandidate candidate) { + return candidate.getFieldMemberId() + "|" + candidate.getExternalMemberId(); + } + + public record PairSelection(boolean hasSolution, List selectedPairs, + String status) { + } +} diff --git a/src/main/java/com/kri/p6/ncrc/pairing/service/PairingScheduleService.java b/src/main/java/com/kri/p6/ncrc/pairing/service/PairingScheduleService.java index 7779130..a0a07b7 100644 --- a/src/main/java/com/kri/p6/ncrc/pairing/service/PairingScheduleService.java +++ b/src/main/java/com/kri/p6/ncrc/pairing/service/PairingScheduleService.java @@ -1,10 +1,9 @@ package com.kri.p6.ncrc.pairing.service; +import com.kri.p6.ncrc.pairing.config.PairingProperties; import com.kri.p6.ncrc.pairing.dto.excel.output.CandidateSummaryExcelDto; import com.kri.p6.ncrc.pairing.dto.excel.output.PairingSummaryExcelDto; -import com.kri.p6.ncrc.pairing.config.PairingProperties; import com.kri.p6.ncrc.pairing.model.AssignmentCandidate; -import com.kri.p6.ncrc.pairing.model.Center; import com.kri.p6.ncrc.pairing.model.Member; import com.kri.p6.ncrc.pairing.model.PairCandidate; import com.kri.p6.ncrc.pairing.model.PairingCandidates; @@ -12,12 +11,14 @@ import com.kri.p6.ncrc.pairing.model.PairingData; import com.kri.p6.ncrc.pairing.model.PairingResult; import java.time.LocalDate; import java.util.ArrayList; +import java.util.Comparator; import java.util.HashMap; import java.util.HashSet; import java.util.LinkedHashMap; import java.util.LinkedHashSet; import java.util.List; import java.util.Map; +import java.util.Optional; import java.util.Set; import java.util.function.Function; import java.util.stream.Collectors; @@ -29,252 +30,757 @@ import org.springframework.stereotype.Service; public class PairingScheduleService { private final PairingCandidateService pairingCandidateService; + private final PairingMemberPairService pairingMemberPairService; private final PairingSolverService pairingSolverService; private final PairingProperties pairingProperties; public PairingResult schedule(PairingData originData) { - List
remainingCenters = new ArrayList<>(originData.getCenters()); - List currentMembers = originData.getMembers(); - List scheduledAssignments = new ArrayList<>(); - List roundCandidates = new ArrayList<>(); + // 전체 배정 흐름: + // 1. 가능한 후보를 생성한다. + // 2. 모든 위원이 조에 포함되도록 조편성을 먼저 확정한다. + // 3. 확정된 조를 기준으로 센터를 greedy 방식으로 배정한다. + // 4. 미배정 센터를 줄이고 방문 수를 균형화하기 위한 repair pass를 순서대로 수행한다. + PairingCandidates candidates = pairingCandidateService.generate(originData); + PairingMemberPairService.PairSelection pairSelection = pairingMemberPairService.select( + originData, candidates.getPairCandidates(), assignmentCountByPair(candidates)); + List selectedPairs = pairSelection.selectedPairs(); + GreedyIndex index = GreedyIndex.of(candidates.getAssignmentCandidates()); + GreedyState state = GreedyState.of(originData, selectedPairs, maxMemberVisitCount(originData)); + List selectedAssignments = new ArrayList<>(); + + String centerStatus = pairSelection.hasSolution() + ? assignRemainingCenters(index, state, selectedAssignments) + : pairSelection.status(); + + +// if (pairSelection.hasSolution()) { +// RepairResult repairResult = repairUnassignedCenters(originData, selectedPairs, index, state, +// selectedAssignments); +// state = repairResult.state(); +// selectedAssignments = repairResult.selectedAssignments(); +// RepairResult lowVisitRepairResult = repairLowVisitMembers(originData, selectedPairs, index, +// state, selectedAssignments); +// state = lowVisitRepairResult.state(); +// selectedAssignments = lowVisitRepairResult.selectedAssignments(); +// RepairResult donorSwapRepairResult = repairByDonorSwap(originData, selectedPairs, index, +// state, selectedAssignments); +// state = donorSwapRepairResult.state(); +// selectedAssignments = donorSwapRepairResult.selectedAssignments(); +// RepairResult wildcardRepairResult = repairWildcardFallbackCenters(originData, selectedPairs, +// index, state, selectedAssignments); +// state = wildcardRepairResult.state(); +// selectedAssignments = wildcardRepairResult.selectedAssignments(); +// centerStatus = remainingCenterStatus(state) + ", repairCount=" + repairResult.repairCount() +// + ", lowVisitRepairCount=" + lowVisitRepairResult.repairCount() +// + ", donorSwapRepairCount=" + donorSwapRepairResult.repairCount() +// + ", wildcardRepairCount=" + wildcardRepairResult.repairCount(); +// } + + String status = pairSelection.hasSolution() + ? "GREEDY_PAIRING_COMPLETED, " + centerStatus + : "GREEDY_FAILED_MEMBER_PAIRING, " + centerStatus; + PairingResult result = pairingSolverService.buildResult(originData, candidates, + selectedAssignments, status, pairedMemberIds(selectedPairs)); + return appendGreedySummaries(result, state, originData.getCenters().size()); + } + + private Map assignmentCountByPair(PairingCandidates candidates) { + return candidates.getAssignmentCandidates().stream() + .collect(Collectors.groupingBy(this::pairKey, Collectors.counting())); + } + + private int maxMemberVisitCount(PairingData data) { + if (data.getMembers().isEmpty()) { + return 0; + } + double fullAssignmentAverage = (double) data.getCenters().size() * 2D + / data.getMembers().size(); + return Math.max(1, (int) Math.ceil(fullAssignmentAverage + * pairingProperties.getRule().getMaxMemberVisitAverageRatioPercent() / 100D)); + } + + private List expandPairsForCoverage(List mandatoryPairs, + PairingCandidates candidates) { + Map assignmentCountByPair = candidates.getAssignmentCandidates().stream() + .collect(Collectors.groupingBy(this::pairKey, Collectors.counting())); + List selectedPairs = new ArrayList<>(mandatoryPairs); + Set selectedPairKeys = selectedPairs.stream() + .map(this::pairKey) + .collect(Collectors.toCollection(LinkedHashSet::new)); Map> counterpartsByMember = new HashMap<>(); - Map visitCountsByMember = createInitialVisitCounts(originData.getMembers()); - int round = 0; - String stopReason = "센터를 모두 배정했습니다."; + selectedPairs.forEach(pair -> addCounterpart(counterpartsByMember, pair)); - while (!remainingCenters.isEmpty() && round < originData.getCenters().size()) { - round++; - PairingData roundData = copyData(originData, currentMembers, remainingCenters); - PairingCandidates candidates = filterByCounterpartLimit( - pairingCandidateService.generate(roundData), counterpartsByMember); - roundCandidates.add(candidates); - PairingSolverService.SolveSelection selection = pairingSolverService.select(candidates, - counterpartsByMember, visitCountsByMember, - mandatoryUnusedMemberIds(candidates, visitCountsByMember)); + candidates.getPairCandidates().stream() + .filter(pair -> !selectedPairKeys.contains(pairKey(pair))) + .filter(pair -> assignmentCountByPair.getOrDefault(pairKey(pair), 0L) > 0) + .sorted(Comparator.comparingLong((PairCandidate pair) -> + assignmentCountByPair.getOrDefault(pairKey(pair), 0L)) + .reversed() + .thenComparing(PairCandidate::getFieldMemberId) + .thenComparing(PairCandidate::getExternalMemberId)) + .forEach(pair -> { + if (canAddCounterpart(counterpartsByMember, pair)) { + selectedPairs.add(pair); + selectedPairKeys.add(pairKey(pair)); + addCounterpart(counterpartsByMember, pair); + } + }); - if (!selection.hasSolution() || selection.selectedAssignments().isEmpty()) { - stopReason = selection.status(); - break; - } - - List selected = selection.selectedAssignments(); - scheduledAssignments.addAll(selected); - addCounterparts(counterpartsByMember, selected); - addVisitCounts(visitCountsByMember, selected); - Set assignedCenterIds = selected.stream() - .map(AssignmentCandidate::getCenterId) - .collect(Collectors.toSet()); - remainingCenters = remainingCenters.stream() - .filter(center -> !assignedCenterIds.contains(center.getId())) - .toList(); - currentMembers = blockAssignedDates(currentMembers, selected); - } - - PairingCandidates mergedCandidates = mergeCandidates(roundCandidates); - PairingResult result = pairingSolverService.buildResult(originData, mergedCandidates, - scheduledAssignments, stopReason(round, remainingCenters, stopReason)); - return appendScheduleSummaries(result, round, originData.getCenters().size(), - remainingCenters.size()); + return selectedPairs; } - private PairingData copyData(PairingData originData, List members, List
centers) { - return PairingData.builder() - .members(members) - .municipalities(originData.getMunicipalities()) - .centers(centers) - .memberRegionCodes(originData.getMemberRegionCodes()) - .centerAdjacentRegions(originData.getCenterAdjacentRegions()) - .preferenceMatchRules(originData.getPreferenceMatchRules()) - .commonUnavailableDates(originData.getCommonUnavailableDates()) - .build(); + private boolean canAddCounterpart(Map> counterpartsByMember, + PairCandidate pair) { + Set fieldCounterparts = counterpartsByMember.getOrDefault(pair.getFieldMemberId(), + Set.of()); + Set externalCounterparts = counterpartsByMember.getOrDefault(pair.getExternalMemberId(), + Set.of()); + return (fieldCounterparts.contains(pair.getExternalMemberId()) + || fieldCounterparts.size() < maxCounterpartsPerMember()) + && (externalCounterparts.contains(pair.getFieldMemberId()) + || externalCounterparts.size() < maxCounterpartsPerMember()); } - private List blockAssignedDates(List members, - List assignments) { - Map> datesByMemberId = new HashMap<>(); - for (AssignmentCandidate assignment : assignments) { - datesByMemberId.computeIfAbsent(assignment.getFieldMemberId(), key -> new HashSet<>()) - .add(assignment.getDate()); - datesByMemberId.computeIfAbsent(assignment.getExternalMemberId(), key -> new HashSet<>()) - .add(assignment.getDate()); - } - - return members.stream() - .map(member -> copyMemberWithBlockedDates(member, - datesByMemberId.getOrDefault(member.getId(), Set.of()))) - .toList(); + private void addCounterpart(Map> counterpartsByMember, PairCandidate pair) { + counterpartsByMember.computeIfAbsent(pair.getFieldMemberId(), key -> new HashSet<>()) + .add(pair.getExternalMemberId()); + counterpartsByMember.computeIfAbsent(pair.getExternalMemberId(), key -> new HashSet<>()) + .add(pair.getFieldMemberId()); } - private PairingCandidates filterByCounterpartLimit(PairingCandidates candidates, - Map> counterpartsByMember) { - Set allowedPairKeys = candidates.getPairCandidates().stream() - .filter(pair -> isAllowedPair(pair.getFieldMemberId(), pair.getExternalMemberId(), - counterpartsByMember)) - .map(pair -> pairKey(pair.getFieldMemberId(), pair.getExternalMemberId())) + private PairingCandidates filterCandidatesByPairs(PairingCandidates candidates, + List selectedPairs) { + Set selectedPairKeys = selectedPairs.stream() + .map(this::pairKey) .collect(Collectors.toSet()); - return PairingCandidates.builder() .pairCandidates(candidates.getPairCandidates().stream() - .filter(pair -> allowedPairKeys.contains( - pairKey(pair.getFieldMemberId(), pair.getExternalMemberId()))) + .filter(candidate -> selectedPairKeys.contains(pairKey(candidate))) .toList()) .dispatchRegionCandidates(candidates.getDispatchRegionCandidates().stream() - .filter(candidate -> allowedPairKeys.contains( - pairKey(candidate.getFieldMemberId(), candidate.getExternalMemberId()))) + .filter(candidate -> selectedPairKeys.contains(pairKey(candidate.getFieldMemberId(), + candidate.getExternalMemberId()))) .toList()) .assignmentCandidates(candidates.getAssignmentCandidates().stream() - .filter(candidate -> allowedPairKeys.contains( - pairKey(candidate.getFieldMemberId(), candidate.getExternalMemberId()))) + .filter(candidate -> selectedPairKeys.contains(pairKey(candidate))) .toList()) .unassignedCenterReasons(candidates.getUnassignedCenterReasons()) .build(); } - private boolean isAllowedPair(String fieldMemberId, String externalMemberId, - Map> counterpartsByMember) { - return isAllowedCounterpart(fieldMemberId, externalMemberId, counterpartsByMember) - && isAllowedCounterpart(externalMemberId, fieldMemberId, counterpartsByMember); + private Set pairedMemberIds(List selectedPairs) { + return selectedPairs.stream() + .flatMap(candidate -> java.util.stream.Stream.of(candidate.getFieldMemberId(), + candidate.getExternalMemberId())) + .collect(Collectors.toCollection(LinkedHashSet::new)); } - private boolean isAllowedCounterpart(String memberId, String counterpartId, - Map> counterpartsByMember) { - Set counterparts = counterpartsByMember.getOrDefault(memberId, Set.of()); - return counterparts.contains(counterpartId) - || counterparts.size() < maxCounterpartsPerMember(); - } + private String assignAllMembersAtLeastOnce(PairingData data, GreedyIndex index, + GreedyState state, List selectedAssignments) { + Set allMemberIds = data.getMembers().stream() + .map(Member::getId) + .collect(Collectors.toCollection(LinkedHashSet::new)); - private void addCounterparts(Map> counterpartsByMember, - List assignments) { - for (AssignmentCandidate assignment : assignments) { - counterpartsByMember.computeIfAbsent(assignment.getFieldMemberId(), key -> new HashSet<>()) - .add(assignment.getExternalMemberId()); - counterpartsByMember.computeIfAbsent(assignment.getExternalMemberId(), key -> new HashSet<>()) - .add(assignment.getFieldMemberId()); + while (true) { + List uncoveredMemberIds = allMemberIds.stream() + .filter(memberId -> state.visitCount(memberId) == 0) + .toList(); + if (uncoveredMemberIds.isEmpty()) { + return ""; + } + + Optional targetMemberId = uncoveredMemberIds.stream() + .min(Comparator.comparingInt((String memberId) -> feasibleCandidatesForMember(memberId, + index, state).size()) + .thenComparing(Function.identity())); + if (targetMemberId.isEmpty()) { + return "입력 위원이 없습니다."; + } + + List feasibleCandidates = feasibleCandidatesForMember( + targetMemberId.get(), index, state); + if (feasibleCandidates.isEmpty()) { + return "최소 1회 배정 후보가 없는 위원: " + targetMemberId.get(); + } + + AssignmentCandidate selected = feasibleCandidates.stream() + .max(Comparator.comparingLong(candidate -> mandatoryAssignmentScore(candidate, state))) + .orElseThrow(); + addAssignment(selectedAssignments, state, selected); } } - private Map createInitialVisitCounts(List members) { - return members.stream() - .collect(Collectors.toMap(Member::getId, member -> 0, (left, right) -> left)); + private String assignRemainingCenters(GreedyIndex index, GreedyState state, + List selectedAssignments) { + // 센터 후보가 가장 적은 센터부터 처리합니다. + // 선택지가 적은 센터를 먼저 잡아야 뒤에서 막히는 상황을 줄일 수 있습니다. + int assignedBefore; + do { + assignedBefore = state.assignedCenterIds().size(); + Optional centerChoice = state.remainingCenterIds().stream() + .map(remainingCenterId -> toCenterChoice(remainingCenterId, index, state)) + .filter(choice -> !choice.feasibleCandidates().isEmpty()) + .min(Comparator.comparingInt((CenterChoice choice) -> choice.feasibleCandidates().size()) + .thenComparing(Comparator.comparingLong(CenterChoice::bestScore).reversed())); + if (centerChoice.isEmpty()) { + break; + } + + AssignmentCandidate selected = centerChoice.get().feasibleCandidates().stream() + .max(Comparator.comparingLong(candidate -> centerAssignmentScore(candidate, state))) + .orElseThrow(); + addAssignment(selectedAssignments, state, selected); + } while (state.assignedCenterIds().size() > assignedBefore); + + return state.remainingCenterIds().isEmpty() + ? "remainingCenters=0" + : "remainingCenters=" + state.remainingCenterIds().size(); } - private Set mandatoryUnusedMemberIds(PairingCandidates candidates, - Map visitCountsByMember) { - return visitCountsByMember.entrySet().stream() - .filter(entry -> entry.getValue() == 0) - .map(Map.Entry::getKey) - .collect(Collectors.toSet()); + private RepairResult repairUnassignedCenters(PairingData data, List fixedPairs, + GreedyIndex index, GreedyState state, List selectedAssignments) { + // 1차 repair: 미배정 센터 하나를 넣기 위해 기존 충돌 배정을 최대 2개까지 빼고 재배정합니다. + // 배정 수가 실제로 늘어나는 경우만 반영합니다. + int repairCount = 0; + boolean changed; + do { + changed = false; + List remainingCenterIds = state.remainingCenterIds().stream() + .sorted(Comparator.comparingInt(centerId -> index.candidatesByCenter() + .getOrDefault(centerId, List.of()).size())) + .toList(); + + for (String centerId : remainingCenterIds) { + RepairAttempt repairAttempt = findRepairAttempt(data, fixedPairs, index, state, + selectedAssignments, centerId); + if (repairAttempt == null) { + continue; + } + + state = repairAttempt.state(); + selectedAssignments = repairAttempt.selectedAssignments(); + repairCount++; + changed = true; + break; + } + } while (changed); + + return new RepairResult(state, selectedAssignments, repairCount); } - private void addVisitCounts(Map visitCountsByMember, - List assignments) { - for (AssignmentCandidate assignment : assignments) { - visitCountsByMember.merge(assignment.getFieldMemberId(), 1, Integer::sum); - visitCountsByMember.merge(assignment.getExternalMemberId(), 1, Integer::sum); - } - } + private RepairAttempt findRepairAttempt(PairingData data, List fixedPairs, + GreedyIndex index, GreedyState state, List selectedAssignments, + String centerId) { + int currentAssignedCount = selectedAssignments.size(); + List candidates = index.candidatesByCenter().getOrDefault(centerId, + List.of()).stream() + .filter(candidate -> !state.assignedCenterIds().contains(candidate.getCenterId())) + .sorted(Comparator.comparingLong((AssignmentCandidate candidate) -> + centerAssignmentScore(candidate, state)) + .reversed()) + .limit(150) + .toList(); - private List filterSelectedByCounterpartLimit( - List selectedAssignments, - Map> counterpartsByMember) { - Map> simulatedCounterparts = copyCounterparts(counterpartsByMember); - List allowedAssignments = new ArrayList<>(); + for (AssignmentCandidate candidate : candidates) { + Set conflictKeys = conflictAssignmentKeys(candidate, state, selectedAssignments); + if (conflictKeys.size() > 2) { + continue; + } - for (AssignmentCandidate assignment : selectedAssignments) { - if (isAllowedPair(assignment.getFieldMemberId(), assignment.getExternalMemberId(), - simulatedCounterparts)) { - allowedAssignments.add(assignment); - simulatedCounterparts.computeIfAbsent(assignment.getFieldMemberId(), key -> new HashSet<>()) - .add(assignment.getExternalMemberId()); - simulatedCounterparts.computeIfAbsent(assignment.getExternalMemberId(), key -> new HashSet<>()) - .add(assignment.getFieldMemberId()); + List repairedAssignments = new ArrayList<>(selectedAssignments.stream() + .filter(assignment -> !conflictKeys.contains(assignmentKey(assignment))) + .toList()); + GreedyState repairedState = rebuildState(data, fixedPairs, repairedAssignments); + if (!isFeasible(candidate, repairedState)) { + continue; + } + + addAssignment(repairedAssignments, repairedState, candidate); + assignRemainingCenters(index, repairedState, repairedAssignments); + if (repairedAssignments.size() > currentAssignedCount) { + return new RepairAttempt(repairedState, repairedAssignments); } } - return allowedAssignments; + return null; } - private Map> copyCounterparts(Map> source) { - Map> copied = new HashMap<>(); - source.forEach((memberId, counterparts) -> copied.put(memberId, new HashSet<>(counterparts))); - return copied; + private RepairResult repairLowVisitMembers(PairingData data, List fixedPairs, + GreedyIndex index, GreedyState state, List selectedAssignments) { + // 2차 repair: 방문 수가 적은 위원이 남은 센터에 들어갈 수 있는지 우선 탐색합니다. + // 배정 수가 같더라도 최대 방문 수나 방문 편차가 개선되면 반영합니다. + int repairCount = 0; + boolean changed; + do { + changed = false; + List lowVisitMemberIds = data.getMembers().stream() + .map(Member::getId) + .sorted(Comparator.comparingInt(state::visitCount).thenComparing(Function.identity())) + .toList(); + + for (String memberId : lowVisitMemberIds) { + RepairAttempt repairAttempt = findLowVisitRepairAttempt(data, fixedPairs, index, state, + selectedAssignments, memberId); + if (repairAttempt == null) { + continue; + } + + state = repairAttempt.state(); + selectedAssignments = repairAttempt.selectedAssignments(); + repairCount++; + changed = true; + break; + } + } while (changed); + + return new RepairResult(state, selectedAssignments, repairCount); } - private String pairKey(PairCandidate pairCandidate) { - return pairKey(pairCandidate.getFieldMemberId(), pairCandidate.getExternalMemberId()); - } + private RepairAttempt findLowVisitRepairAttempt(PairingData data, List fixedPairs, + GreedyIndex index, GreedyState state, List selectedAssignments, + String memberId) { + ScheduleQuality currentQuality = ScheduleQuality.of(state, selectedAssignments.size()); + Set remainingCenterIds = state.remainingCenterIds(); + List candidates = index.candidatesByMember() + .getOrDefault(memberId, List.of()).stream() + .filter(candidate -> remainingCenterIds.contains(candidate.getCenterId())) + .sorted(Comparator.comparingInt((AssignmentCandidate candidate) -> + memberVisitSumAsInt(candidate, state)) + .thenComparing(Comparator.comparingLong((AssignmentCandidate candidate) -> + centerAssignmentScore(candidate, state)).reversed())) + .limit(200) + .toList(); - private String pairKey(String fieldMemberId, String externalMemberId) { - return fieldMemberId + "|" + externalMemberId; - } + for (AssignmentCandidate candidate : candidates) { + Set conflictKeys = conflictAssignmentKeys(candidate, state, selectedAssignments); + if (conflictKeys.size() > 2) { + continue; + } - private int maxCounterpartsPerMember() { - return pairingProperties.getRule().getMaxCounterpartsPerMember(); - } + List repairedAssignments = new ArrayList<>(selectedAssignments.stream() + .filter(assignment -> !conflictKeys.contains(assignmentKey(assignment))) + .toList()); + GreedyState repairedState = rebuildState(data, fixedPairs, repairedAssignments); + if (!isFeasible(candidate, repairedState)) { + continue; + } - private Member copyMemberWithBlockedDates(Member member, Set additionalDates) { - if (additionalDates.isEmpty()) { - return member; + addAssignment(repairedAssignments, repairedState, candidate); + assignRemainingCenters(index, repairedState, repairedAssignments); + ScheduleQuality repairedQuality = ScheduleQuality.of(repairedState, + repairedAssignments.size()); + if (repairedQuality.isBetterThan(currentQuality)) { + return new RepairAttempt(repairedState, repairedAssignments); + } } - Set unavailableDates = new LinkedHashSet<>(member.getUnavailableDates()); - unavailableDates.addAll(additionalDates); - return Member.builder() - .id(member.getId()) - .gender(member.getGender()) - .experienceType(member.getExperienceType()) - .role(member.getRole()) - .availableStartDate(member.getAvailableStartDate()) - .availableEndDate(member.getAvailableEndDate()) - .unavailableDates(unavailableDates) - .activityRegion(member.getActivityRegion()) - .historyCenterIds(member.getHistoryCenterIds()) - .residenceCode(member.getResidenceCode()) - .preferenceRegions(member.getPreferenceRegions()) - .build(); + return null; } - private PairingCandidates mergeCandidates(List roundCandidates) { - Map> reasons = new LinkedHashMap<>(); - roundCandidates.stream() - .map(PairingCandidates::getUnassignedCenterReasons) - .forEach(reasonMap -> reasonMap.forEach((centerId, centerReasons) -> - reasons.computeIfAbsent(centerId, key -> new LinkedHashSet<>()).addAll(centerReasons))); + private RepairResult repairByDonorSwap(PairingData data, List fixedPairs, + GreedyIndex index, GreedyState state, List selectedAssignments) { + // 3차 repair: 방문 수가 많은 위원의 배정을 donor로 보고, + // 같은 센터를 저방문 위원이 포함된 다른 후보에게 넘길 수 있는지 시도합니다. + int repairCount = 0; + boolean changed; + do { + changed = false; + RepairAttempt repairAttempt = findDonorSwapRepairAttempt(data, fixedPairs, index, state, + selectedAssignments); + if (repairAttempt != null) { + state = repairAttempt.state(); + selectedAssignments = repairAttempt.selectedAssignments(); + repairCount++; + changed = true; + } + } while (changed); - return PairingCandidates.builder() - .pairCandidates(roundCandidates.stream() - .flatMap(candidates -> candidates.getPairCandidates().stream()) - .toList()) - .dispatchRegionCandidates(roundCandidates.stream() - .flatMap(candidates -> candidates.getDispatchRegionCandidates().stream()) - .toList()) - .assignmentCandidates(roundCandidates.stream() - .flatMap(candidates -> candidates.getAssignmentCandidates().stream()) - .toList()) - .unassignedCenterReasons(reasons) - .build(); + return new RepairResult(state, selectedAssignments, repairCount); } - private String stopReason(int round, List
remainingCenters, String stopReason) { - if (remainingCenters.isEmpty()) { - return "SCHEDULE_COMPLETED"; + private RepairAttempt findDonorSwapRepairAttempt(PairingData data, List fixedPairs, + GreedyIndex index, GreedyState state, List selectedAssignments) { + ScheduleQuality currentQuality = ScheduleQuality.of(state, selectedAssignments.size()); + double averageVisitCount = averageVisitCount(state); + List donorAssignments = selectedAssignments.stream() + .sorted(Comparator.comparingInt((AssignmentCandidate assignment) -> + memberVisitSumAsInt(assignment, state)) + .reversed() + .thenComparing(AssignmentCandidate::getCenterId)) + .limit(300) + .toList(); + + for (AssignmentCandidate donorAssignment : donorAssignments) { + int donorVisitSum = memberVisitSumAsInt(donorAssignment, state); + if (!hasHighVisitMember(donorAssignment, state, averageVisitCount)) { + continue; + } + + List receiverCandidates = index.candidatesByCenter() + .getOrDefault(donorAssignment.getCenterId(), List.of()).stream() + .filter(candidate -> !assignmentKey(candidate).equals(assignmentKey(donorAssignment))) + .filter(candidate -> memberVisitSumAsInt(candidate, state) < donorVisitSum) + .filter(candidate -> hasLowVisitMember(candidate, state, averageVisitCount)) + .sorted(Comparator.comparingInt((AssignmentCandidate candidate) -> + memberVisitSumAsInt(candidate, state)) + .thenComparing(Comparator.comparingLong((AssignmentCandidate candidate) -> + centerAssignmentScore(candidate, state)).reversed())) + .limit(120) + .toList(); + + for (AssignmentCandidate receiverCandidate : receiverCandidates) { + Set conflictKeys = conflictAssignmentKeys(receiverCandidate, state, + selectedAssignments); + conflictKeys.add(assignmentKey(donorAssignment)); + if (conflictKeys.size() > 3) { + continue; + } + + List repairedAssignments = new ArrayList<>(selectedAssignments.stream() + .filter(assignment -> !conflictKeys.contains(assignmentKey(assignment))) + .toList()); + GreedyState repairedState = rebuildState(data, fixedPairs, repairedAssignments); + if (!isFeasible(receiverCandidate, repairedState)) { + continue; + } + + addAssignment(repairedAssignments, repairedState, receiverCandidate); + assignRemainingCenters(index, repairedState, repairedAssignments); + ScheduleQuality repairedQuality = ScheduleQuality.of(repairedState, + repairedAssignments.size()); + if (repairedQuality.isBetterThan(currentQuality)) { + return new RepairAttempt(repairedState, repairedAssignments); + } + } } - return "SCHEDULE_STOPPED round=" + round + ", remainingCenters=" + remainingCenters.size() - + ", reason=" + stopReason; + return null; } - private PairingResult appendScheduleSummaries(PairingResult result, int round, - int originalCenterCount, int remainingCenterCount) { + private RepairResult repairWildcardFallbackCenters(PairingData data, List fixedPairs, + GreedyIndex index, GreedyState state, List selectedAssignments) { + // 4차 repair: 99 wildcard 규칙으로 만들어진 후보를 남은 센터에 적극 적용합니다. + // yml의 active-wildcard-fallback-enabled=false이면 이 단계는 비활성화됩니다. + if (!pairingProperties.getPreference().isActiveWildcardFallbackEnabled()) { + return new RepairResult(state, selectedAssignments, 0); + } + + int repairCount = 0; + boolean changed; + do { + changed = false; + List remainingCenterIds = state.remainingCenterIds().stream() + .sorted(Comparator.comparingInt(centerId -> wildcardCandidatesForCenter(centerId, index) + .size())) + .toList(); + + for (String centerId : remainingCenterIds) { + RepairAttempt repairAttempt = findWildcardRepairAttempt(data, fixedPairs, index, state, + selectedAssignments, centerId); + if (repairAttempt == null) { + continue; + } + + state = repairAttempt.state(); + selectedAssignments = repairAttempt.selectedAssignments(); + repairCount++; + changed = true; + break; + } + } while (changed); + + return new RepairResult(state, selectedAssignments, repairCount); + } + + private RepairAttempt findWildcardRepairAttempt(PairingData data, List fixedPairs, + GreedyIndex index, GreedyState state, List selectedAssignments, + String centerId) { + int currentAssignedCount = selectedAssignments.size(); + List candidates = wildcardCandidatesForCenter(centerId, index).stream() + .filter(candidate -> !state.assignedCenterIds().contains(candidate.getCenterId())) + .sorted(Comparator.comparingLong((AssignmentCandidate candidate) -> + centerAssignmentScore(candidate, state)) + .reversed()) + .limit(500) + .toList(); + + for (AssignmentCandidate candidate : candidates) { + Set conflictKeys = conflictAssignmentKeys(candidate, state, selectedAssignments); + if (conflictKeys.size() > 3) { + continue; + } + + List repairedAssignments = new ArrayList<>(selectedAssignments.stream() + .filter(assignment -> !conflictKeys.contains(assignmentKey(assignment))) + .toList()); + GreedyState repairedState = rebuildState(data, fixedPairs, repairedAssignments); + if (!isFeasible(candidate, repairedState)) { + continue; + } + + addAssignment(repairedAssignments, repairedState, candidate); + assignRemainingCenters(index, repairedState, repairedAssignments); + if (repairedAssignments.size() > currentAssignedCount) { + return new RepairAttempt(repairedState, repairedAssignments); + } + } + + return null; + } + + private Set conflictAssignmentKeys(AssignmentCandidate candidate, GreedyState state, + List selectedAssignments) { + // 새 후보를 넣을 때 같은 날짜에 같은 위원이 다른 조와 이미 일하는지, + // 같은 조/같은 날짜에 다른 인접지역 분류를 방문하게 되는지 확인합니다. + // repair 단계에서는 여기서 찾은 기존 배정을 제거한 뒤 상태를 다시 계산합니다. + Set conflicts = new LinkedHashSet<>(); + String candidatePairKey = pairKey(candidate); + String candidatePairDayKey = pairDayKey(candidate); + + selectedAssignments.forEach(assignment -> { + if (assignment.getDate().equals(candidate.getDate()) + && !pairKey(assignment).equals(candidatePairKey) + && sharesMember(candidate, assignment)) { + conflicts.add(assignmentKey(assignment)); + } + if (pairDayKey(assignment).equals(candidatePairDayKey) + && !assignment.getAdjacentRegionClassification() + .equals(candidate.getAdjacentRegionClassification())) { + conflicts.add(assignmentKey(assignment)); + } + }); + + if (state.pairDayCount(candidatePairDayKey) >= maxCentersPerPairPerDay()) { + selectedAssignments.stream() + .filter(assignment -> pairDayKey(assignment).equals(candidatePairDayKey)) + .min(Comparator.comparingLong(assignment -> centerAssignmentScore(assignment, state))) + .map(this::assignmentKey) + .ifPresent(conflicts::add); + } + + return conflicts; + } + + private boolean sharesMember(AssignmentCandidate left, AssignmentCandidate right) { + return left.getFieldMemberId().equals(right.getFieldMemberId()) + || left.getFieldMemberId().equals(right.getExternalMemberId()) + || left.getExternalMemberId().equals(right.getFieldMemberId()) + || left.getExternalMemberId().equals(right.getExternalMemberId()); + } + + private GreedyState rebuildState(PairingData data, List fixedPairs, + List assignments) { + GreedyState rebuiltState = GreedyState.of(data, fixedPairs, maxMemberVisitCount(data)); + assignments.forEach(rebuiltState::add); + return rebuiltState; + } + + private String remainingCenterStatus(GreedyState state) { + return state.remainingCenterIds().isEmpty() + ? "remainingCenters=0" + : "remainingCenters=" + state.remainingCenterIds().size(); + } + + private CenterChoice toCenterChoice(String centerId, GreedyIndex index, GreedyState state) { + List feasibleCandidates = feasibleCandidatesForCenter(centerId, index, + state); + long bestScore = feasibleCandidates.stream() + .mapToLong(candidate -> centerAssignmentScore(candidate, state)) + .max() + .orElse(Long.MIN_VALUE); + return new CenterChoice(centerId, feasibleCandidates, bestScore); + } + + private List feasibleCandidatesForMember(String memberId, GreedyIndex index, + GreedyState state) { + return index.candidatesByMember().getOrDefault(memberId, List.of()).stream() + .filter(candidate -> isFeasible(candidate, state)) + .toList(); + } + + private List feasibleCandidatesForCenter(String centerId, GreedyIndex index, + GreedyState state) { + return index.candidatesByCenter().getOrDefault(centerId, List.of()).stream() + .filter(candidate -> isFeasible(candidate, state)) + .toList(); + } + + private boolean isFeasible(AssignmentCandidate candidate, GreedyState state) { + // 최종 선택 직전의 HARD 룰 검사입니다. + // 후보 생성 단계에서 걸러진 규칙 외에, 이미 배정된 일정과의 충돌을 여기서 다시 확인합니다. + if (state.assignedCenterIds().contains(candidate.getCenterId())) { + return false; + } + if (!state.canVisit(candidate.getFieldMemberId()) + || !state.canVisit(candidate.getExternalMemberId())) { + return false; + } + String pairKey = pairKey(candidate); + if (state.isMemberBusyWithOtherPair(candidate.getFieldMemberId(), candidate.getDate(), pairKey) + || state.isMemberBusyWithOtherPair(candidate.getExternalMemberId(), candidate.getDate(), + pairKey)) { + return false; + } + if (!state.isAllowedCounterpart(candidate.getFieldMemberId(), + candidate.getExternalMemberId(), maxCounterpartsPerMember()) + || !state.isAllowedCounterpart(candidate.getExternalMemberId(), + candidate.getFieldMemberId(), maxCounterpartsPerMember())) { + return false; + } + if (state.pairDayCount(pairDayKey(candidate)) >= maxCentersPerPairPerDay()) { + return false; + } + return state.isAllowedAdjacentClassification(pairDayKey(candidate), + candidate.getAdjacentRegionClassification()); + } + + private long mandatoryAssignmentScore(AssignmentCandidate candidate, GreedyState state) { + long uncoveredCount = (state.visitCount(candidate.getFieldMemberId()) == 0 ? 1L : 0L) + + (state.visitCount(candidate.getExternalMemberId()) == 0 ? 1L : 0L); + return uncoveredCount * 10_000_000_000L + - memberVisitSum(candidate, state) * memberBalanceWeight() + + preferenceScore(candidate) * 100L + + residenceScore(candidate) + - datePenalty(candidate); + } + + private long centerAssignmentScore(AssignmentCandidate candidate, GreedyState state) { + // greedy가 후보 하나를 고를 때 쓰는 점수입니다. + // 이미 같은 조/같은 날짜/같은 인접지역으로 묶인 후보를 선호하고, + // 방문 수가 많은 위원은 점수를 깎아 균형을 맞춥니다. + return samePairDayReuseScore(candidate, state) + + counterpartReuseScore(candidate, state) + - memberVisitSum(candidate, state) * memberBalanceWeight() + + preferenceScore(candidate) * 100L + + residenceScore(candidate) + - datePenalty(candidate); + } + + private long samePairDayReuseScore(AssignmentCandidate candidate, GreedyState state) { + int usedCount = state.pairDayCount(pairDayKey(candidate)); + if (usedCount <= 0) { + return 0L; + } + //return 5_000_000L + usedCount * 1_000_000L; + + return 0L; + } + + private long counterpartReuseScore(AssignmentCandidate candidate, GreedyState state) { + boolean fieldHasCounterpart = state.hasCounterpart(candidate.getFieldMemberId(), + candidate.getExternalMemberId()); + boolean externalHasCounterpart = state.hasCounterpart(candidate.getExternalMemberId(), + candidate.getFieldMemberId()); + return (fieldHasCounterpart && externalHasCounterpart) ? 2_000_000L : 0L; + } + + private long memberVisitSum(AssignmentCandidate candidate, GreedyState state) { + return (long) state.visitCount(candidate.getFieldMemberId()) + + state.visitCount(candidate.getExternalMemberId()); + } + + private int memberVisitSumAsInt(AssignmentCandidate candidate, GreedyState state) { + return state.visitCount(candidate.getFieldMemberId()) + + state.visitCount(candidate.getExternalMemberId()); + } + + private double averageVisitCount(GreedyState state) { + return state.visitCountsByMember.values().stream() + .mapToInt(Integer::intValue) + .average() + .orElse(0D); + } + + private boolean hasHighVisitMember(AssignmentCandidate candidate, GreedyState state, + double averageVisitCount) { + return state.visitCount(candidate.getFieldMemberId()) > averageVisitCount + || state.visitCount(candidate.getExternalMemberId()) > averageVisitCount; + } + + private boolean hasLowVisitMember(AssignmentCandidate candidate, GreedyState state, + double averageVisitCount) { + return state.visitCount(candidate.getFieldMemberId()) < averageVisitCount + || state.visitCount(candidate.getExternalMemberId()) < averageVisitCount; + } + + private List wildcardCandidatesForCenter(String centerId, + GreedyIndex index) { + return index.candidatesByCenter().getOrDefault(centerId, List.of()).stream() + .filter(this::usesWildcardFallback) + .toList(); + } + + private boolean usesWildcardFallback(AssignmentCandidate candidate) { + return candidate.getFieldMemberPreferenceRank() < 0 + || candidate.getExternalMemberPreferenceRank() < 0; + } + + private long preferenceScore(AssignmentCandidate candidate) { + return Math.max(0L, pairingProperties.getObjective().getPreferenceBaseWeight() + - candidate.getPreferencePriority() + * pairingProperties.getObjective().getPreferenceRankPenalty()) + + wildcardFallbackBonus(candidate); + } + + private long wildcardFallbackBonus(AssignmentCandidate candidate) { + if (!pairingProperties.getPreference().isActiveWildcardFallbackEnabled()) { + return 0L; + } + if (!usesWildcardFallback(candidate)) { + return 0L; + } + return pairingProperties.getPreference().getWildcardFallbackScoreBonus(); + } + + private long residenceScore(AssignmentCandidate candidate) { + return candidate.getResidenceMatchScore() + * pairingProperties.getObjective().getResidenceMatchWeight(); + } + + private long datePenalty(AssignmentCandidate candidate) { + return candidate.getDate().toEpochDay(); + } + + private void addAssignment(List selectedAssignments, GreedyState state, + AssignmentCandidate assignment) { + selectedAssignments.add(assignment); + state.add(assignment); + } + + private void addSameRouteAssignments(GreedyIndex index, GreedyState state, + List selectedAssignments, AssignmentCandidate baseAssignment) { + String routeKey = pairDayAdjacentKey(baseAssignment); + List sameRouteCandidates = index.candidatesByPairDayAdjacent() + .getOrDefault(routeKey, List.of()).stream() + .filter(candidate -> !candidate.getCenterId().equals(baseAssignment.getCenterId())) + .filter(candidate -> isFeasible(candidate, state)) + .sorted(Comparator.comparingLong((AssignmentCandidate candidate) -> + centerAssignmentScore(candidate, state)) + .reversed()) + .toList(); + + for (AssignmentCandidate candidate : sameRouteCandidates) { + if (state.pairDayCount(pairDayKey(baseAssignment)) >= maxCentersPerPairPerDay()) { + break; + } + if (isFeasible(candidate, state)) { + addAssignment(selectedAssignments, state, candidate); + } + } + } + + private PairingResult appendGreedySummaries(PairingResult result, GreedyState state, + int originalCenterCount) { List summaries = new ArrayList<>(result.getSummaries()); - summaries.add(new PairingSummaryExcelDto("스케줄링 라운드 수", String.valueOf(round))); - summaries.add(new PairingSummaryExcelDto("스케줄링 시작 센터 수", String.valueOf(originalCenterCount))); - summaries.add(new PairingSummaryExcelDto("스케줄링 잔여 센터 수", String.valueOf(remainingCenterCount))); + summaries.add(new PairingSummaryExcelDto("그리디 배정 센터 수", + String.valueOf(state.assignedCenterIds().size()))); + summaries.add(new PairingSummaryExcelDto("그리디 잔여 센터 수", + String.valueOf(originalCenterCount - state.assignedCenterIds().size()))); List candidateSummaries = new ArrayList<>( result.getCandidateSummaries()); - candidateSummaries.add(new CandidateSummaryExcelDto("스케줄링 라운드 수", - String.valueOf(round), "배정 후 위원 불가일과 잔여 센터를 갱신한 반복 횟수")); + candidateSummaries.add(new CandidateSummaryExcelDto("그리디 배정 방식", "ON", + "모든 위원 최소 1회 배정을 먼저 수행한 뒤 남은 센터를 배정합니다.")); return PairingResult.builder() .assignments(result.getAssignments()) @@ -283,8 +789,223 @@ public class PairingScheduleService { .summaries(summaries) .abPairs(result.getAbPairs()) .candidateSummaries(candidateSummaries) + .appliedSettings(result.getAppliedSettings()) .validationErrors(result.getValidationErrors()) .ruleViolations(result.getRuleViolations()) .build(); } + + private String pairKey(AssignmentCandidate candidate) { + return candidate.getFieldMemberId() + "|" + candidate.getExternalMemberId(); + } + + private String pairKey(PairCandidate candidate) { + return pairKey(candidate.getFieldMemberId(), candidate.getExternalMemberId()); + } + + private String pairKey(String fieldMemberId, String externalMemberId) { + return fieldMemberId + "|" + externalMemberId; + } + + private String pairDayKey(AssignmentCandidate candidate) { + return pairKey(candidate) + "|" + candidate.getDate(); + } + + private String pairDayAdjacentKey(AssignmentCandidate candidate) { + return pairDayKey(candidate) + "|" + candidate.getAdjacentRegionClassification(); + } + + private String assignmentKey(AssignmentCandidate candidate) { + return pairKey(candidate) + "|" + candidate.getCenterId() + "|" + candidate.getDate(); + } + + private int maxCounterpartsPerMember() { + return pairingProperties.getRule().getMaxCounterpartsPerMember(); + } + + private int maxCentersPerPairPerDay() { + return pairingProperties.getRule().getMaxCentersPerPairPerDay(); + } + + private long memberBalanceWeight() { + return pairingProperties.getObjective().getMemberBalanceWeight(); + } + + private record GreedyIndex(Map> candidatesByMember, + Map> candidatesByCenter, + Map> candidatesByPairDayAdjacent) { + + private static GreedyIndex of(List candidates) { + Map> byMember = new HashMap<>(); + Map> byCenter = new LinkedHashMap<>(); + Map> byPairDayAdjacent = new HashMap<>(); + for (AssignmentCandidate candidate : candidates) { + byMember.computeIfAbsent(candidate.getFieldMemberId(), key -> new ArrayList<>()) + .add(candidate); + byMember.computeIfAbsent(candidate.getExternalMemberId(), key -> new ArrayList<>()) + .add(candidate); + byCenter.computeIfAbsent(candidate.getCenterId(), key -> new ArrayList<>()) + .add(candidate); + String pairDayAdjacentKey = candidate.getFieldMemberId() + "|" + + candidate.getExternalMemberId() + "|" + candidate.getDate() + "|" + + candidate.getAdjacentRegionClassification(); + byPairDayAdjacent.computeIfAbsent(pairDayAdjacentKey, key -> new ArrayList<>()) + .add(candidate); + } + return new GreedyIndex(byMember, byCenter, byPairDayAdjacent); + } + } + + private record CenterChoice(String centerId, List feasibleCandidates, + long bestScore) { + } + + private record RepairAttempt(GreedyState state, + List selectedAssignments) { + } + + private record RepairResult(GreedyState state, List selectedAssignments, + int repairCount) { + } + + private record ScheduleQuality(int assignedCount, int maxVisitCount, long squaredVisitSum) { + + private static ScheduleQuality of(GreedyState state, int assignedCount) { + int maxVisitCount = state.visitCountsByMember.values().stream() + .mapToInt(Integer::intValue) + .max() + .orElse(0); + long squaredVisitSum = state.visitCountsByMember.values().stream() + .mapToLong(visitCount -> (long) visitCount * visitCount) + .sum(); + return new ScheduleQuality(assignedCount, maxVisitCount, squaredVisitSum); + } + + private boolean isBetterThan(ScheduleQuality other) { + // repair 결과 비교 기준: + // 1. 배정 센터 수가 더 많으면 우선 + // 2. 배정 수가 같으면 최대 방문 수가 낮은 결과 우선 + // 3. 그래도 같으면 방문 수 편차가 작은 결과 우선 + if (assignedCount != other.assignedCount) { + return assignedCount > other.assignedCount; + } + if (maxVisitCount != other.maxVisitCount) { + return maxVisitCount < other.maxVisitCount; + } + return squaredVisitSum < other.squaredVisitSum; + } + } + + private static final class GreedyState { + + // GreedyState는 "현재까지의 배정표"입니다. + // 센터 배정 여부, 위원별 방문 횟수, 날짜별 조 사용 여부 등을 들고 있다가 + // 새 후보가 들어갈 수 있는지 빠르게 판단하게 해줍니다. + private final Set allCenterIds; + private final Set assignedCenterIds = new LinkedHashSet<>(); + private final Map visitCountsByMember = new HashMap<>(); + private final Map> pairKeysByMemberDate = new HashMap<>(); + private final Map> counterpartsByMember = new HashMap<>(); + private final Map pairDayCounts = new HashMap<>(); + private final Map> adjacentClassificationsByPairDay = new HashMap<>(); + private final int maxVisitCount; + + private GreedyState(Set allCenterIds, int maxVisitCount) { + this.allCenterIds = allCenterIds; + this.maxVisitCount = maxVisitCount; + } + + private static GreedyState of(PairingData data, List fixedPairs, + int maxVisitCount) { + Set centerIds = data.getCenters().stream() + .map(com.kri.p6.ncrc.pairing.model.Center::getId) + .collect(Collectors.toCollection(LinkedHashSet::new)); + GreedyState state = new GreedyState(centerIds, maxVisitCount); + data.getMembers().forEach(member -> { + state.visitCountsByMember.put(member.getId(), 0); + state.counterpartsByMember.put(member.getId(), new HashSet<>()); + }); + fixedPairs.forEach(pair -> { + state.counterpartsByMember.computeIfAbsent(pair.getFieldMemberId(), key -> new HashSet<>()) + .add(pair.getExternalMemberId()); + state.counterpartsByMember.computeIfAbsent(pair.getExternalMemberId(), + key -> new HashSet<>()) + .add(pair.getFieldMemberId()); + }); + return state; + } + + private void add(AssignmentCandidate assignment) { + assignedCenterIds.add(assignment.getCenterId()); + visitCountsByMember.merge(assignment.getFieldMemberId(), 1, Integer::sum); + visitCountsByMember.merge(assignment.getExternalMemberId(), 1, Integer::sum); + String pairKey = assignment.getFieldMemberId() + "|" + assignment.getExternalMemberId(); + pairKeysByMemberDate.computeIfAbsent(memberDateKey(assignment.getFieldMemberId(), + assignment.getDate()), key -> new HashSet<>()) + .add(pairKey); + pairKeysByMemberDate.computeIfAbsent(memberDateKey(assignment.getExternalMemberId(), + assignment.getDate()), key -> new HashSet<>()) + .add(pairKey); + counterpartsByMember.computeIfAbsent(assignment.getFieldMemberId(), key -> new HashSet<>()) + .add(assignment.getExternalMemberId()); + counterpartsByMember.computeIfAbsent(assignment.getExternalMemberId(), key -> new HashSet<>()) + .add(assignment.getFieldMemberId()); + String pairDayKey = assignment.getFieldMemberId() + "|" + assignment.getExternalMemberId() + + "|" + assignment.getDate(); + pairDayCounts.merge(pairDayKey, 1, Integer::sum); + adjacentClassificationsByPairDay.computeIfAbsent(pairDayKey, key -> new HashSet<>()) + .add(assignment.getAdjacentRegionClassification()); + } + + private int visitCount(String memberId) { + return visitCountsByMember.getOrDefault(memberId, 0); + } + + private boolean canVisit(String memberId) { + return visitCount(memberId) < maxVisitCount; + } + + private boolean isMemberBusyWithOtherPair(String memberId, LocalDate date, String pairKey) { + Set pairKeys = pairKeysByMemberDate.getOrDefault(memberDateKey(memberId, date), + Set.of()); + return !pairKeys.isEmpty() && !pairKeys.contains(pairKey); + } + + private String memberDateKey(String memberId, LocalDate date) { + return memberId + "|" + date; + } + + private boolean isAllowedCounterpart(String memberId, String counterpartId, + int maxCounterpartsPerMember) { + Set counterparts = counterpartsByMember.getOrDefault(memberId, Set.of()); + return counterparts.contains(counterpartId) + || counterparts.size() < maxCounterpartsPerMember; + } + + private boolean hasCounterpart(String memberId, String counterpartId) { + return counterpartsByMember.getOrDefault(memberId, Set.of()).contains(counterpartId); + } + + private int pairDayCount(String pairDayKey) { + return pairDayCounts.getOrDefault(pairDayKey, 0); + } + + private boolean isAllowedAdjacentClassification(String pairDayKey, + String adjacentRegionClassification) { + Set adjacentClassifications = adjacentClassificationsByPairDay.getOrDefault( + pairDayKey, Set.of()); + return adjacentClassifications.isEmpty() + || adjacentClassifications.contains(adjacentRegionClassification); + } + + private Set assignedCenterIds() { + return assignedCenterIds; + } + + private Set remainingCenterIds() { + Set remaining = new LinkedHashSet<>(allCenterIds); + remaining.removeAll(assignedCenterIds); + return remaining; + } + } } diff --git a/src/main/java/com/kri/p6/ncrc/pairing/service/PairingSolverService.java b/src/main/java/com/kri/p6/ncrc/pairing/service/PairingSolverService.java index 43f85fa..195d9e3 100644 --- a/src/main/java/com/kri/p6/ncrc/pairing/service/PairingSolverService.java +++ b/src/main/java/com/kri/p6/ncrc/pairing/service/PairingSolverService.java @@ -11,6 +11,7 @@ import com.kri.p6.ncrc.pairing.common.enums.ExperienceType; import com.kri.p6.ncrc.pairing.common.enums.Gender; import com.kri.p6.ncrc.pairing.config.PairingProperties; import com.kri.p6.ncrc.pairing.dto.excel.output.ABPairExcelDto; +import com.kri.p6.ncrc.pairing.dto.excel.output.AppliedSettingExcelDto; import com.kri.p6.ncrc.pairing.dto.excel.output.AssignmentResultExcelDto; import com.kri.p6.ncrc.pairing.dto.excel.output.CandidateSummaryExcelDto; import com.kri.p6.ncrc.pairing.dto.excel.output.PairingSummaryExcelDto; @@ -52,7 +53,7 @@ public class PairingSolverService { if (!selection.hasSolution()) { return emptyResult(data, candidates, selection.status()); } - return toResult(data, candidates, selection.selectedAssignments(), selection.status()); + return toResult(data, candidates, selection.selectedAssignments(), selection.status(), Set.of()); } public SolveSelection select(PairingCandidates candidates) { @@ -61,65 +62,40 @@ public class PairingSolverService { public SolveSelection select(PairingCandidates candidates, Map> existingCounterpartsByMember) { - return select(candidates, existingCounterpartsByMember, Map.of(), Set.of()); + return select(candidates, existingCounterpartsByMember, Map.of()); } public SolveSelection select(PairingCandidates candidates, - Map> existingCounterpartsByMember, Map visitCountsByMember, - Set mandatoryMemberIds) { - return select(candidates, existingCounterpartsByMember, visitCountsByMember, mandatoryMemberIds, - true); - } - - private SolveSelection select(PairingCandidates candidates, - Map> existingCounterpartsByMember, Map visitCountsByMember, - Set mandatoryMemberIds, boolean enforceCounterpartLimit) { + Map> existingCounterpartsByMember, + Map visitCountsByMember) { if (candidates.getAssignmentCandidates().isEmpty()) { return new SolveSelection(false, List.of(), "배정 가능한 후보가 없습니다."); } CpModel model = new CpModel(); List assignmentCandidates = candidates.getAssignmentCandidates(); + // CP-SAT에서는 각 배정 후보를 0/1 변수로 봅니다. + // 1이면 해당 후보 선택, 0이면 미선택입니다. BoolVar[] assignmentVars = createAssignmentVars(model, assignmentCandidates); Map pairUsedVars = createPairUsedVars(model, assignmentCandidates); Map pairDayVars = createPairDayVars(model, assignmentCandidates); Map pairDayAdjacentVars = createPairDayAdjacentVars(model, assignmentCandidates); - Map memberUsedVars = createMemberUsedVars(model, assignmentCandidates); - Set missingMandatoryMemberIds = mandatoryMemberIds.stream() - .filter(memberId -> !memberUsedVars.containsKey(memberId)) - .collect(Collectors.toCollection(LinkedHashSet::new)); - if (!missingMandatoryMemberIds.isEmpty()) { - return new SolveSelection(false, List.of(), - "필수 조편성 위원의 배정 후보가 없습니다: " + String.join(", ", missingMandatoryMemberIds)); - } + // 현재 메인 배정은 Greedy가 담당하지만, CP-SAT 모델은 부분 최적화와 기존 방식 호환을 위해 유지합니다. linkHelperVars(model, assignmentCandidates, assignmentVars, pairUsedVars, pairDayVars, pairDayAdjacentVars); - linkMemberUsedVars(model, assignmentCandidates, assignmentVars, memberUsedVars); - addMandatoryMemberUsed(model, memberUsedVars, mandatoryMemberIds); addCenterAssignedAtMostOnce(model, assignmentCandidates, assignmentVars); addPairDailyCapacity(model, assignmentCandidates, assignmentVars); addMemberDailyOnePair(model, assignmentCandidates, pairDayVars); addPairDailyOneAdjacentClassification(model, assignmentCandidates, pairDayAdjacentVars); - if (enforceCounterpartLimit) { - addCumulativeBuddyLimit(model, assignmentCandidates, pairUsedVars, - existingCounterpartsByMember); - } - model.maximize(createObjective(assignmentCandidates, assignmentVars, memberUsedVars, - visitCountsByMember)); + addCumulativeBuddyLimit(model, assignmentCandidates, pairUsedVars, + existingCounterpartsByMember); + model.maximize(createObjective(assignmentCandidates, assignmentVars, visitCountsByMember)); CpSolver solver = new CpSolver(); solver.getParameters().setMaxTimeInSeconds(pairingProperties.getSolver().getMaxTimeSeconds()); solver.getParameters().setNumSearchWorkers(pairingProperties.getSolver().getNumSearchWorkers()); CpSolverStatus status = solver.solve(model); if (status != CpSolverStatus.OPTIMAL && status != CpSolverStatus.FEASIBLE) { - if (enforceCounterpartLimit && !mandatoryMemberIds.isEmpty()) { - SolveSelection counterpartRelaxedSelection = select(candidates, - existingCounterpartsByMember, visitCountsByMember, mandatoryMemberIds, false); - if (counterpartRelaxedSelection.hasSolution()) { - return new SolveSelection(true, counterpartRelaxedSelection.selectedAssignments(), - counterpartRelaxedSelection.status() + ", counterpartLimitRelaxed=true"); - } - } return new SolveSelection(false, List.of(), "solver가 feasible 해를 찾지 못했습니다: " + status); } return new SolveSelection(true, collectSelectedAssignments(assignmentCandidates, assignmentVars, solver), status.name()); @@ -127,7 +103,12 @@ public class PairingSolverService { public PairingResult buildResult(PairingData data, PairingCandidates candidates, List selectedAssignments, String status) { - return toResult(data, candidates, selectedAssignments, status); + return toResult(data, candidates, selectedAssignments, status, Set.of()); + } + + public PairingResult buildResult(PairingData data, PairingCandidates candidates, + List selectedAssignments, String status, Set pairedMemberIds) { + return toResult(data, candidates, selectedAssignments, status, pairedMemberIds); } private BoolVar[] createAssignmentVars(CpModel model, List candidates) { @@ -153,16 +134,6 @@ public class PairingSolverService { .collect(Collectors.toMap(Function.identity(), key -> model.newBoolVar("pair_day_adjacent_" + key))); } - private Map createMemberUsedVars(CpModel model, - List candidates) { - return candidates.stream() - .flatMap(candidate -> Stream.of(candidate.getFieldMemberId(), - candidate.getExternalMemberId())) - .distinct() - .collect(Collectors.toMap(Function.identity(), - memberId -> model.newBoolVar("member_used_" + memberId))); - } - private void linkHelperVars(CpModel model, List candidates, BoolVar[] assignmentVars, Map pairUsedVars, Map pairDayVars, Map pairDayAdjacentVars) { @@ -174,40 +145,16 @@ public class PairingSolverService { } } - private void linkMemberUsedVars(CpModel model, List candidates, - BoolVar[] assignmentVars, Map memberUsedVars) { - Map> indexesByMember = new HashMap<>(); - for (int i = 0; i < candidates.size(); i++) { - AssignmentCandidate candidate = candidates.get(i); - indexesByMember.computeIfAbsent(candidate.getFieldMemberId(), key -> new ArrayList<>()) - .add(i); - indexesByMember.computeIfAbsent(candidate.getExternalMemberId(), key -> new ArrayList<>()) - .add(i); - model.addLessOrEqual(assignmentVars[i], memberUsedVars.get(candidate.getFieldMemberId())); - model.addLessOrEqual(assignmentVars[i], memberUsedVars.get(candidate.getExternalMemberId())); - } - - indexesByMember.forEach((memberId, indexes) -> model.addLessOrEqual( - memberUsedVars.get(memberId), LinearExpr.sum(toLinearArgumentArray(indexes, - assignmentVars)))); - } - - private void addMandatoryMemberUsed(CpModel model, Map memberUsedVars, - Set mandatoryMemberIds) { - mandatoryMemberIds.stream() - .map(memberUsedVars::get) - .filter(Objects::nonNull) - .forEach(memberUsedVar -> model.addEquality(memberUsedVar, 1)); - } - private void addCenterAssignedAtMostOnce(CpModel model, List candidates, BoolVar[] assignmentVars) { + // 하나의 센터는 최대 1번만 배정됩니다. groupIndexes(candidates, AssignmentCandidate::getCenterId).values() .forEach(indexes -> model.addAtMostOne(toLiteralArray(indexes, assignmentVars))); } private void addPairDailyCapacity(CpModel model, List candidates, BoolVar[] assignmentVars) { + // 같은 조가 하루에 방문할 수 있는 센터 수 상한입니다. groupIndexes(candidates, this::pairDayKey).values().forEach(indexes -> model.addLessOrEqual( LinearExpr.sum(toLinearArgumentArray(indexes, assignmentVars)), pairingProperties.getRule().getMaxCentersPerPairPerDay())); @@ -215,6 +162,7 @@ public class PairingSolverService { private void addMemberDailyOnePair(CpModel model, List candidates, Map pairDayVars) { + // 한 위원은 같은 날짜에 여러 조로 동시에 활동할 수 없습니다. Map> pairDayKeysByMemberDay = candidates.stream() .collect(Collectors.groupingBy(candidate -> candidate.getFieldMemberId() + "|" + candidate.getDate(), Collectors.mapping(this::pairDayKey, Collectors.toSet()))); @@ -231,6 +179,7 @@ public class PairingSolverService { private void addPairDailyOneAdjacentClassification(CpModel model, List candidates, Map pairDayAdjacentVars) { + // 같은 조/같은 날짜에는 하나의 인접지역 분류만 방문합니다. Map> adjacentKeysByPairDay = candidates.stream() .collect(Collectors.groupingBy(this::pairDayKey, Collectors.mapping(this::pairDayAdjacentKey, Collectors.toSet()))); @@ -240,6 +189,7 @@ public class PairingSolverService { private void addCumulativeBuddyLimit(CpModel model, List candidates, Map pairUsedVars, Map> existingCounterpartsByMember) { + // 위원 1명당 누적 상대 위원 수 제한입니다. 현재 업무 기준은 application.yaml의 max-counterparts-per-member입니다. Map> pairKeysByMember = candidates.stream() .collect(Collectors.groupingBy(AssignmentCandidate::getFieldMemberId, Collectors.mapping(this::pairKey, Collectors.toSet()))); @@ -270,8 +220,9 @@ public class PairingSolverService { } private LinearExpr createObjective(List candidates, - BoolVar[] assignmentVars, Map memberUsedVars, - Map visitCountsByMember) { + BoolVar[] assignmentVars, Map visitCountsByMember) { + // soft rule 점수입니다. 센터를 많이 배정하는 점수가 가장 크고, + // 희망지역/거주지/방문 균형은 같은 배정 수 안에서 우열을 정하는 보조 점수입니다. List vars = new ArrayList<>(); List weights = new ArrayList<>(); for (int i = 0; i < assignmentVars.length; i++) { @@ -284,13 +235,6 @@ public class PairingSolverService { - memberBalancePenalty(candidate, visitCountsByMember)); } - memberUsedVars.forEach((memberId, memberUsedVar) -> { - if (visitCountsByMember.getOrDefault(memberId, 0) == 0) { - vars.add(memberUsedVar); - weights.add(pairingProperties.getObjective().getUsedMemberWeight()); - } - }); - return LinearExpr.weightedSum(vars.toArray(LinearArgument[]::new), weights.stream().mapToLong(Long::longValue).toArray()); } @@ -316,11 +260,12 @@ public class PairingSolverService { return selected; } private PairingResult toResult(PairingData data, PairingCandidates candidates, - List selectedAssignments, String status) { + List selectedAssignments, String status, Set pairedMemberIds) { Set assignedCenterIds = selectedAssignments.stream().map(AssignmentCandidate::getCenterId).collect(Collectors.toSet()); Set usedMemberIds = selectedAssignments.stream() .flatMap(candidate -> Stream.of(candidate.getFieldMemberId(), candidate.getExternalMemberId())) .collect(Collectors.toSet()); + usedMemberIds.addAll(pairedMemberIds); Map memberMap = data.getMembers().stream() .collect(Collectors.toMap(Member::getId, Function.identity(), (left, right) -> left)); Map centerMap = data.getCenters().stream() @@ -350,8 +295,9 @@ public class PairingSolverService { .abPairs(abPairBuildResult.rows()) .candidateSummaries(createCandidateSummaries(data, candidates, assignments.size(), unassignedCenters.size(), unusedMembers.size(), countABGroups(abPairMatches))) + .appliedSettings(createAppliedSettings()) .validationErrors(List.of()) - .ruleViolations(createRuleChecks(data, selectedAssignments, abPairMatches)) + .ruleViolations(createRuleChecks(data, selectedAssignments, abPairMatches, pairedMemberIds)) .build(); } @@ -367,6 +313,7 @@ public class PairingSolverService { .summaries(createSummaries(data, candidates, 0, data.getCenters().size(), data.getMembers().size(), 0, reason)) .abPairs(List.of()) .candidateSummaries(createCandidateSummaries(data, candidates, 0, data.getCenters().size(), data.getMembers().size(), 0)) + .appliedSettings(createAppliedSettings()) .validationErrors(List.of()) .ruleViolations(List.of(new RuleViolationExcelDto("solver feasible 해", "FAIL", reason))) .build(); @@ -395,8 +342,8 @@ public class PairingSolverService { } private UnassignedCenterExcelDto toUnassignedCenter(Center center, Map> reasonMap) { - Set reasons = new LinkedHashSet<>((Collection) (reasonMap == null ? Set.of() - : reasonMap.getOrDefault(center.getId(), Set.of()))); + Set reasons = new LinkedHashSet<>(reasonMap == null ? Set.of() + : reasonMap.getOrDefault(center.getId(), Set.of())); reasons.add("solver 최적화에서 선택되지 않음"); return new UnassignedCenterExcelDto(center.getId(), center.getMunicipalityId(), String.join(", ", reasons)); } @@ -521,8 +468,96 @@ public class PairingSolverService { new CandidateSummaryExcelDto("AB 그룹 수", String.valueOf(abGroupCount), "후처리로 구성된 AB 그룹 수")); } + private List createAppliedSettings() { + PairingProperties.Excel excel = pairingProperties.getExcel(); + PairingProperties.Code code = pairingProperties.getCode(); + PairingProperties.Rule rule = pairingProperties.getRule(); + PairingProperties.Preference preference = pairingProperties.getPreference(); + PairingProperties.Objective objective = pairingProperties.getObjective(); + PairingProperties.Candidate candidate = pairingProperties.getCandidate(); + PairingProperties.Solver solver = pairingProperties.getSolver(); + return List.of( + setting("pairing.excel.header-row-index", + "엑셀 헤더로 사용할 행 인덱스", + excel.getHeaderRowIndex()), + setting("pairing.code.region-code-length", + "지역코드 정규화 길이", code.getRegionCodeLength()), + setting("pairing.code.residence-code-length", + "거주지코드 정규화 길이", + code.getResidenceCodeLength()), + setting("pairing.code.residence-match-prefix-length", + "거주지 일치 판단에 사용하는 앞자리 길이", + code.getResidenceMatchPrefixLength()), + setting("pairing.code.any-region-code", + "희망지역 anywhere로 처리하는 코드", + code.getAnyRegionCode()), + setting("pairing.rule.max-centers-per-pair-per-day", + "페어가 하루에 방문할 수 있는 최대 센터 수", + rule.getMaxCentersPerPairPerDay()), + setting("pairing.rule.max-counterparts-per-member", + "위원 1명당 허용되는 상대 위원 최대 수", + rule.getMaxCounterpartsPerMember()), + setting("pairing.rule.max-member-visit-average-ratio-percent", + "위원별 방문 수 상한을 평균 대비 몇 %까지 허용할지", + rule.getMaxMemberVisitAverageRatioPercent()), + setting("pairing.preference.anywhere-rank", + "선호지역 anywhere를 의미하는 순위", + preference.getAnywhereRank()), + setting("pairing.preference.ignored-rank", + "선호지역 고려하지 않음을 의미하는 순위", + preference.getIgnoredRank()), + setting("pairing.preference.active-wildcard-fallback-enabled", + "희망지역 고려하지 않음을 wildcard로 적극 사용할지", + preference.isActiveWildcardFallbackEnabled()), + setting("pairing.preference.wildcard-fallback-score-bonus", + "wildcard 후보에 추가할 점수", + preference.getWildcardFallbackScoreBonus()), + setting("pairing.objective.assignment-weight", + "센터 하나를 더 배정하는 것에 부여하는 기본 점수", + objective.getAssignmentWeight()), + setting("pairing.objective.preference-base-weight", + "희망지역 매칭 품질에 부여하는 기본 점수", + objective.getPreferenceBaseWeight()), + setting("pairing.objective.preference-rank-penalty", + "희망순위가 낮아질 때 감점하는 점수", + objective.getPreferenceRankPenalty()), + setting("pairing.objective.residence-match-weight", + "거주지 유사도 점수에 곱하는 가중치", + objective.getResidenceMatchWeight()), + setting("pairing.objective.member-balance-weight", + "방문 수가 많은 위원을 더 선택하지 않도록 감점하는 가중치", + objective.getMemberBalanceWeight()), + setting("pairing.candidate.max-pair-candidates-per-member", + "위원별 페어 후보 축소 상한, 0이면 무제한", + candidate.getMaxPairCandidatesPerMember()), + setting("pairing.candidate.max-dispatch-regions-per-pair", + "페어별 파견 권역 후보 축소 상한, 0이면 무제한", + candidate.getMaxDispatchRegionsPerPair()), + setting("pairing.candidate.max-assignments-per-center", + "센터별 배정 후보 축소 상한", + candidate.getMaxAssignmentsPerCenter()), + setting("pairing.candidate.max-assignments-per-member", + "위원별 배정 후보 축소 상한", + candidate.getMaxAssignmentsPerMember()), + setting("pairing.candidate.max-dates-per-assignment-candidate", + "하나의 페어-센터 조합에서 확장할 날짜 후보 상한", + candidate.getMaxDatesPerAssignmentCandidate()), + setting("pairing.solver.max-time-seconds", + "CP-SAT 사용 시 허용할 최대 탐색 시간", + solver.getMaxTimeSeconds()), + setting("pairing.solver.num-search-workers", + "CP-SAT 사용 시 사용할 worker 수", + solver.getNumSearchWorkers()) + ); + } + + private AppliedSettingExcelDto setting(String name, String description, Object value) { + return new AppliedSettingExcelDto(name, description, String.valueOf(value)); + } + private List createRuleChecks(PairingData data, - List selectedAssignments, Map abPairMatches) { + List selectedAssignments, Map abPairMatches, + Set pairedMemberIds) { Map memberMap = data.getMembers().stream() .collect(Collectors.toMap(Member::getId, Function.identity(), (left, right) -> left)); Map centerMap = data.getCenters().stream() @@ -538,8 +573,9 @@ public class PairingSolverService { checks.add(checkHistoryCenter(selectedAssignments, memberMap)); checks.add(checkHoliday(selectedAssignments, commonUnavailableDates(data))); checks.add(checkABDateOverlap(abPairMatches)); - checks.add(checkAllMembersUsed(data, selectedAssignments)); + checks.add(checkAllMembersUsed(data, selectedAssignments, pairedMemberIds)); checks.add(checkMemberVisitBalance(data, selectedAssignments)); + checks.add(checkMemberVisitUpperBound(data, selectedAssignments)); return checks; } @@ -638,11 +674,12 @@ public class PairingSolverService { } private RuleViolationExcelDto checkAllMembersUsed(PairingData data, - List assignments) { + List assignments, Set pairedMemberIds) { Set usedMemberIds = assignments.stream() .flatMap(candidate -> Stream.of(candidate.getFieldMemberId(), candidate.getExternalMemberId())) .collect(Collectors.toSet()); + usedMemberIds.addAll(pairedMemberIds); List unusedMemberIds = data.getMembers().stream() .map(Member::getId) .filter(memberId -> !usedMemberIds.contains(memberId)) @@ -662,10 +699,39 @@ public class PairingSolverService { long min = visitCounts.values().stream().mapToLong(Long::longValue).min().orElse(0L); long max = visitCounts.values().stream().mapToLong(Long::longValue).max().orElse(0L); double average = visitCounts.values().stream().mapToLong(Long::longValue).average().orElse(0.0D); - String detail = "min=" + min + ", max=" + max + ", avg=" + String.format("%.2f", average); + long maxAllowed = maxMemberVisitCount(data); + String detail = "min=" + min + ", max=" + max + ", avg=" + String.format("%.2f", average) + + ", maxAllowed=" + maxAllowed; return new RuleViolationExcelDto("위원별 방문 센터 수 균등 배분", "PASS", detail); } + private long maxMemberVisitCount(PairingData data) { + if (data.getMembers().isEmpty()) { + return 0L; + } + double fullAssignmentAverage = (double) data.getCenters().size() * 2D + / data.getMembers().size(); + return Math.max(1L, (long) Math.ceil(fullAssignmentAverage + * pairingProperties.getRule().getMaxMemberVisitAverageRatioPercent() / 100D)); + } + + private RuleViolationExcelDto checkMemberVisitUpperBound(PairingData data, + List assignments) { + Map visitCounts = data.getMembers().stream() + .collect(Collectors.toMap(Member::getId, member -> 0L, (left, right) -> left)); + assignments.forEach(candidate -> { + visitCounts.merge(candidate.getFieldMemberId(), 1L, Long::sum); + visitCounts.merge(candidate.getExternalMemberId(), 1L, Long::sum); + }); + long max = visitCounts.values().stream().mapToLong(Long::longValue).max().orElse(0L); + long maxAllowed = maxMemberVisitCount(data); + String detail = "max=" + max + ", maxAllowed=" + maxAllowed + + ", ratioPercent=" + pairingProperties.getRule() + .getMaxMemberVisitAverageRatioPercent(); + return new RuleViolationExcelDto("위원 최대 방문 센터 수 상한", + max <= maxAllowed ? "PASS" : "FAIL", detail); + } + private String formatDates(Set dates) { return dates.stream().sorted().map(LocalDate::toString).collect(Collectors.joining(", ")); } diff --git a/src/main/resources/application.yaml b/src/main/resources/application.yaml index 5d6289b..fcfcc87 100644 --- a/src/main/resources/application.yaml +++ b/src/main/resources/application.yaml @@ -61,37 +61,44 @@ pairing: # 한 페어가 하루에 방문할 수 있는 최대 센터 수입니다. (HARD) max-centers-per-pair-per-day: 3 # 한 위원이 전체 기간 동안 가질 수 있는 최대 상대 파트너 수입니다.(HARD) - max-counterparts-per-member: 2 + max-counterparts-per-member: 3 + # 위원 1명의 최대 방문 센터 수 상한입니다. 전체 센터가 모두 배정됐을 때 평균 방문 수의 N%를 넘지 못하게 합니다.(HARD) + max-member-visit-average-ratio-percent: 130 preference: # 선호지역 00(anywhere)을 희망지역 매칭표에서 표현하는 rank 값입니다.(HARD) anywhere-rank: 0 # 희망지역 매칭표에서 해당 위원의 선호지역을 고려하지 않는 wildcard rank 값입니다.(HARD) ignored-rank: 99 + # true면 선호지역 미일치 후보도 99 wildcard 매칭표 규칙을 적극 활용합니다. false로 바꾸면 기존 보수적 점수로 되돌아갑니다. + active-wildcard-fallback-enabled: true + # wildcard 후보가 후보 축소/배정 선택에서 너무 뒤로 밀리지 않도록 더하는 점수입니다. 값이 클수록 미배정 센터 감소를 우선합니다. + wildcard-fallback-score-bonus: 25_000 objective: # 센터 1개를 배정했을 때 부여하는 최우선 점수입니다. 다른 soft score 총합보다 충분히 커야 합니다. assignment-weight: 1_000_000 - # 최종 배정에 위원 1명이 새로 포함될 때 부여하는 점수입니다. 값이 클수록 미사용 위원을 줄이는 방향으로 탐색합니다. - used-member-weight: 300_000 # 이미 많이 배정된 위원이 추가 배정될 때 차감하는 점수입니다. 값이 클수록 위원별 방문 센터 수를 평균에 가깝게 분산합니다. - member-balance-weight: 100_000 - # 거주지 prefix가 일치하는 페어에 부여하는 점수입니다. 값이 클수록 거주지 유사도를 더 중요하게 봅니다. - residence-match-weight: 30_000 + member-balance-weight: 20_000 # 희망지역 매칭 순위 점수의 기준값입니다. 값이 클수록 선호지역 품질 영향이 커집니다. - preference-base-weight: 1_000 + preference-base-weight: 30_000 # 매칭 순위가 1 내려갈 때마다 차감하는 점수입니다. 값이 클수록 낮은 순위를 더 강하게 불리하게 봅니다. - preference-rank-penalty: 100 + preference-rank-penalty: 1_000 + # 거주지 prefix가 일치하는 페어에 부여하는 점수입니다. 값이 클수록 거주지 유사도를 더 중요하게 봅니다. + residence-match-weight: 10_000 candidate: + # 위원 1명당 유지할 상대 위원 후보 수입니다. 0이면 제한하지 않습니다. + # 모든 위원 조편성이 최우선 HARD 룰이므로 기본값은 제한 없음으로 둡니다. + max-pair-candidates-per-member: 0 # 현장+외부 페어 1개가 solver에 넘기기 전에 유지할 최대 파견 권역 후보 수입니다. - max-dispatch-regions-per-pair: 20 + max-dispatch-regions-per-pair: 0 # 센터 1개마다 solver에 넘기기 전에 유지할 최대 배정 후보 수입니다. - max-assignments-per-center: 100 + max-assignments-per-center: 1_000 # 위원 1명(현장/외부 모두 포함)이 solver 후보에 등장할 수 있는 최대 횟수입니다. - max-assignments-per-member: 160 - # 페어-센터 후보 1개에서 생성할 최대 가능 날짜 수입니다. 값이 클수록 전원 조편성 가능성은 커지지만 solver 후보 수가 늘어납니다. - max-dates-per-assignment-candidate: 5 + max-assignments-per-member: 3_000 + # 페어-센터 후보 1개에서 생성할 최대 가능 날짜 수입니다. 기간 전체에 고르게 분산해 날짜 쏠림을 줄입니다. + max-dates-per-assignment-candidate: 80 solver: # OR-Tools CP-SAT solver가 한 요청에서 탐색할 최대 시간(초)입니다. - max-time-seconds: 120.0 + max-time-seconds: 360.0 # OR-Tools CP-SAT 병렬 탐색 worker 수입니다. 서버 CPU 상황에 맞춰 조정합니다. num-search-workers: 15 diff --git a/src/main/resources/sample/배정_규칙_및_완화_검토.md b/src/main/resources/sample/배정_규칙_및_완화_검토.md new file mode 100644 index 0000000..c9609e3 --- /dev/null +++ b/src/main/resources/sample/배정_규칙_및_완화_검토.md @@ -0,0 +1,105 @@ +# 배정 규칙 및 완화 검토 자료 + +이 문서는 개발자가 아닌 업무 담당자와 배정 기준을 논의하기 위한 설명 자료입니다. + +현재 프로그램은 "모든 위원을 조편성한 뒤, 가능한 많은 센터를 일정표에 배정"하는 것을 목표로 합니다. 단, 일부 규칙은 반드시 지켜야 하므로 센터가 남을 수 있습니다. + +## 용어 설명 + +| 용어 | 설명 | +| --- | --- | +| 현장위원/외부위원 | 한 조를 구성하는 두 역할입니다. 현재 기본 조는 현장위원 1명 + 외부위원 1명입니다. | +| 센터 배정 | 특정 날짜에 특정 조가 특정 센터를 방문하도록 정하는 것입니다. | +| 상피제 | 위원의 활동지역과 같은 파견 권역에는 배정하지 않는 규칙입니다. | +| 희망지역 00 | 어디든 가능하다는 응답입니다. | +| 희망지역 99 | 희망지역을 고려하지 않는다는 매칭표의 wildcard 규칙입니다. | +| Greedy | 그때그때 가장 좋아 보이는 선택을 빠르게 고르는 방식입니다. 사람으로 비유하면 "막히기 쉬운 센터부터 먼저 잡고, 가능한 후보 중 점수가 좋은 조를 넣는 방식"입니다. | +| CP-SAT | 여러 조건을 동시에 만족하는 조합을 찾는 최적화 도구입니다. 모든 후보를 놓고 수학적으로 좋은 조합을 찾지만, 후보가 많으면 시간이 오래 걸립니다. | +| repair pass | 1차 배정 후 남은 센터를 줄이기 위해 일부 배정을 빼고 다시 끼워 넣어 보는 후처리입니다. | + +## 현재 처리 순서 + +1. 엑셀 파일을 읽습니다. +2. 날짜, 지역코드, 성별, 경력, 불가능일, 희망지역 등 입력값을 정리합니다. +3. 공휴일과 토/일을 공통 불가능일로 추가합니다. +4. 입력 데이터의 필수값과 참조 오류를 검증합니다. +5. 가능한 후보를 생성합니다. +6. 모든 위원이 최소 1개 조에 포함되도록 조편성을 먼저 합니다. +7. 확정된 조를 기준으로 센터 일정을 Greedy 방식으로 배정합니다. +8. 미배정 센터를 줄이기 위해 후처리를 순서대로 수행합니다. +9. 결과 엑셀을 생성합니다. + +## 현재 Hard Rule + +Hard Rule은 반드시 지켜야 하는 규칙입니다. 이 규칙을 어기면서 센터를 더 배정하지 않습니다. + +| 우선순위 | 규칙 | 설명 | 현재 완화 가능성 | +| --- | --- | --- | --- | +| 0 | 모든 위원 조편성 | 모든 위원은 최소 1개 이상의 조에 포함되어야 합니다. | 완화 불가 | +| 1 | 역할 조합 | 현장위원 1명 + 외부위원 1명으로 조를 구성합니다. | 낮음 | +| 2 | 위원 활동 가능 기간 | 두 위원의 활동 가능 기간이 겹쳐야 조 후보가 됩니다. | 낮음 | +| 3 | 날짜 불가 | 위원, 지자체, 센터의 불가능일에는 배정하지 않습니다. | 중간 | +| 4 | 공통 불가능일 | 공휴일과 토/일에는 배정하지 않습니다. | 중간 | +| 5 | 상피제 | 위원의 활동지역과 같은 파견 권역에는 배정하지 않습니다. | 높음 | +| 6 | 여성전용센터 | 여성전용센터는 여성 위원 2명 조만 배정합니다. | 중간 | +| 7 | 기방문센터 제외 | 2023년에 해당 위원이 진행한 센터는 제외합니다. | 높음 | +| 8 | 센터 중복 배정 금지 | 센터 1개는 결과에서 최대 1번만 배정됩니다. | 완화 불가 | +| 9 | 같은 날짜 위원 중복 금지 | 한 위원은 같은 날짜에 여러 조로 동시에 활동할 수 없습니다. | 낮음 | +| 10 | 같은 조의 하루 방문 상한 | 같은 조는 하루 최대 3개 센터까지 방문합니다. | 높음 | +| 11 | 같은 조/날짜의 인접지역 분류 | 같은 조가 같은 날짜에는 하나의 인접지역 분류만 방문합니다. | 높음 | +| 12 | 위원당 상대 파트너 수 | 위원 1명당 최대 3명의 상대 위원까지만 허용합니다. | 높음 | +| 13 | 위원별 최대 방문 상한 | 전체 센터가 모두 배정됐을 때의 평균 방문 수 대비 130%를 넘지 않게 합니다. | 높음 | + +## 현재 Soft Rule + +Soft Rule은 가능하면 지키는 규칙입니다. Hard Rule을 모두 지킨 후보 중에서 더 좋은 후보를 고르는 기준입니다. + +| 우선순위 | 규칙 | 설명 | +| --- | --- | --- | +| 1 | 배정 센터 수 최대화 | 가장 중요한 목표입니다. 희망지역 품질보다 센터를 더 많이 배정하는 것이 우선입니다. | +| 2 | 위원별 방문 수 균형 | 특정 위원에게 센터가 과도하게 몰리지 않도록 합니다. | +| 3 | 희망지역 매칭 품질 | 희망지역 매칭표의 우선순위가 좋은 후보를 선호합니다. | +| 4 | 희망지역 99 wildcard 활용 | 선호지역이 직접 맞지 않아도 "선호지역 고려하지 않음" 규칙으로 후보를 살릴 수 있습니다. 현재 옵션으로 켜져 있습니다. | +| 5 | 거주지 유사도 | 거주지 코드 앞 3자리, 없으면 2자리가 같은 조를 선호합니다. | +| 6 | 같은 조/같은 날짜 묶음 | 이미 같은 조가 같은 날짜에 같은 인접지역 분류를 방문한다면 추가 센터를 묶어서 배정하려고 합니다. | + +## 후처리 방식 + +1차 Greedy 배정 후에도 남은 센터가 있으면 아래 순서로 다시 시도합니다. + +| 순서 | 후처리 | 설명 | +| --- | --- | --- | +| 1 | 일반 repair | 미배정 센터 하나를 넣기 위해 충돌되는 기존 배정을 최대 2개까지 빼고 다시 배정합니다. | +| 2 | 저방문 위원 중심 repair | 방문 수가 적은 위원이 남은 센터에 들어갈 수 있는지 먼저 봅니다. | +| 3 | donor-swap repair | 방문 수가 많은 위원의 기존 배정을 빼고, 같은 센터를 저방문 위원이 포함된 조로 넘길 수 있는지 봅니다. | +| 4 | wildcard repair | 희망지역 99 wildcard로 살아난 후보를 남은 센터에 우선 적용해 봅니다. | + +## Greedy와 CP-SAT의 현재 역할 + +현재 1차 배정은 Greedy 중심입니다. + +Greedy는 빠르고 큰 데이터에 비교적 안정적으로 동작합니다. 대신 처음 선택한 조합이 뒤쪽 선택에 영향을 주므로, 항상 이론상 최적이라고 보장하지는 않습니다. 그래서 후처리 단계에서 일부 배정을 교환하면서 보정합니다. + +CP-SAT는 조건을 모두 수학 모델로 만들어 더 좋은 조합을 찾는 방식입니다. 다만 후보 수가 커지면 시간이 매우 오래 걸리고 PC 사양 영향을 크게 받습니다. 현재 프로젝트에서는 CP-SAT 코드를 유지하되, 전체 배정의 중심은 Greedy로 옮겨 둔 상태입니다. + +## 완화하면 미배정 센터가 늘어날 가능성이 큰 순서 + +아래 순서는 "센터 배정 수 증가 가능성" 기준입니다. 실제 정책적으로 허용 가능한지는 별도 협의가 필요합니다. + +| 추천 순서 | 완화 대상 | 기대 효과 | 업무 리스크 | +| --- | --- | --- | --- | +| 1 | 위원별 최대 방문 상한 130% | 현재 max=24에서 더 많은 센터를 넣을 여지가 생깁니다. | 일부 위원에게 방문이 몰릴 수 있습니다. | +| 2 | 위원당 상대 파트너 수 3명 | 조 선택지가 늘어나 날짜/센터 후보가 크게 늘 수 있습니다. | 한 위원이 여러 사람과 조를 이루게 되어 운영 복잡도가 증가합니다. | +| 3 | 같은 조 하루 최대 3개 센터 | 같은 날짜에 더 많은 센터를 묶을 수 있습니다. | 이동 가능성, 업무 피로도 확인이 필요합니다. | +| 4 | 같은 조/날짜의 인접지역 분류 1개 제한 | 인접지역 분류가 다른 센터도 같은 날 묶을 수 있습니다. | 실제 이동 동선이 나빠질 수 있습니다. | +| 5 | 기방문센터 제외 | 특정 위원이 과거 방문한 센터도 다시 갈 수 있어 후보가 늘어납니다. | 기존 정책 취지와 충돌할 수 있습니다. | +| 6 | 상피제 | 활동지역과 파견 권역이 같은 경우도 허용하면 후보가 늘어납니다. | 이해충돌 방지 취지와 충돌할 수 있습니다. | +| 7 | 날짜 불가 일부 완화 | 위원/센터/지자체 일정 제약이 줄어듭니다. | 실제 운영 가능 여부 확인이 필요합니다. | +| 8 | 공휴일/토/일 배정 허용 | 날짜 후보가 늘어납니다. | 운영 정책상 허용 가능성이 낮습니다. | +| 9 | 여성전용센터 성별 조건 | 일부 센터 후보가 늘어납니다. | 정책 리스크가 큽니다. | + +## 현재 결과 해석 시 주의점 + +미배정 센터가 남는다고 해서 희망지역만 문제라는 뜻은 아닙니다. 현재는 희망지역 99 wildcard도 사용하도록 열어 둔 상태입니다. 그래도 남는 센터는 날짜, 상피제, 성별, 기방문센터, 하루 방문 상한, 파트너 수, 방문 수 상한이 복합적으로 막고 있을 가능성이 큽니다. + +따라서 클라이언트와 논의할 때는 "희망지역을 더 넓게 보는 것"보다 "어떤 Hard Rule을 어느 수준까지 완화할 수 있는지"가 배정률 개선의 핵심입니다. diff --git a/src/test/java/com/kri/p6/ncrc/pairing/service/PairingServiceTest.java b/src/test/java/com/kri/p6/ncrc/pairing/service/PairingServiceTest.java index 32c6718..8c2c92c 100644 --- a/src/test/java/com/kri/p6/ncrc/pairing/service/PairingServiceTest.java +++ b/src/test/java/com/kri/p6/ncrc/pairing/service/PairingServiceTest.java @@ -10,9 +10,6 @@ import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_VALIDATION_ERROR; import com.kri.common.feature.excel.ExcelMapper; -import com.kri.p6.ncrc.pairing.common.cache.DatagoHolidayCache; -import com.kri.p6.ncrc.pairing.common.external.datago.DatagoExtentionApiClient; -import com.kri.p6.ncrc.pairing.common.external.datago.HolidayDto; import com.kri.p6.ncrc.pairing.dto.excel.output.RuleViolationExcelDto; import java.io.ByteArrayInputStream; import java.io.IOException; @@ -24,28 +21,35 @@ import org.apache.poi.ss.usermodel.Workbook; import org.apache.poi.ss.usermodel.WorkbookFactory; import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc; +import org.springframework.boot.test.context.SpringBootTest; import org.springframework.mock.web.MockMultipartFile; +import org.springframework.test.web.servlet.MockMvc; +import org.springframework.test.web.servlet.MvcResult; +import org.springframework.test.web.servlet.request.MockMvcRequestBuilders; +import org.springframework.test.web.servlet.result.MockMvcResultMatchers; +@SpringBootTest +@AutoConfigureMockMvc class PairingServiceTest { - private final PairingService pairingService = new PairingService( - new PairingExcelService(PairingTestSupport.pairingProperties()), - new PairingNormalizeService(PairingTestSupport.pairingProperties()), - new PairingHolidayService(new DatagoHolidayCache(new StubDatagoExtentionApiClient())), - new PairingValidationService(PairingTestSupport.pairingProperties()), - new PairingScheduleService( - new PairingCandidateService(PairingTestSupport.pairingProperties()), - new PairingSolverService(PairingTestSupport.pairingProperties()), - PairingTestSupport.pairingProperties()) - ); + @Autowired + private MockMvc mockMvc; @Test - void pairingMemberByCenterCreatesResultWorkbook() throws IOException { - try (InputStream inputStream = getClass().getResourceAsStream("/sample/기초 data TEST.xlsx")) { - MockMultipartFile file = new MockMultipartFile("file", "기초 data TEST.xlsx", + void pairingMemberByCenterCreatesResultWorkbook() throws Exception { + Path sample = Path.of("src/main/resources/sample/기초 data TEST.xlsx"); + + try (InputStream inputStream = Files.newInputStream(sample)) { + MockMultipartFile file = new MockMultipartFile("file", sample.getFileName().toString(), "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", inputStream); - byte[] result = pairingService.pairingMemberByCenter(file); + MvcResult mvcResult = mockMvc.perform(MockMvcRequestBuilders.multipart("/api/v1/pairing/run") + .file(file)) + .andExpect(MockMvcResultMatchers.status().isOk()) + .andReturn(); + byte[] result = mvcResult.getResponse().getContentAsByteArray(); Assertions.assertThat(result).isNotEmpty(); Files.createDirectories(Path.of("build")); @@ -63,21 +67,9 @@ class PairingServiceTest { List ruleChecks = ExcelMapper.readFromWorkbook(workbook, RuleViolationExcelDto.class, RESULT_SHEET_RULE_CHECK, 1); Assertions.assertThat(ruleChecks) - .filteredOn(ruleCheck -> !"위원 전원 조편성".equals(ruleCheck.getRuleName())) .extracting(RuleViolationExcelDto::getResult) .doesNotContain("FAIL"); - Assertions.assertThat(ruleChecks) - .extracting(RuleViolationExcelDto::getRuleName) - .contains("위원 전원 조편성", "위원별 방문 센터 수 균등 배분"); } } } - - private static class StubDatagoExtentionApiClient extends DatagoExtentionApiClient { - - @Override - public List getHoliDayList(String year) { - return List.of(); - } - } } diff --git a/src/test/java/com/kri/p6/ncrc/pairing/service/PairingSolverServiceTest.java b/src/test/java/com/kri/p6/ncrc/pairing/service/PairingSolverServiceTest.java index 6ff95e0..b81bb26 100644 --- a/src/test/java/com/kri/p6/ncrc/pairing/service/PairingSolverServiceTest.java +++ b/src/test/java/com/kri/p6/ncrc/pairing/service/PairingSolverServiceTest.java @@ -49,13 +49,13 @@ class PairingSolverServiceTest { } @Test - void solveLimitsCounterpartsPerMemberToTwo() { + void solveLimitsCounterpartsPerMemberToThree() { PairingData data = dataWithMembersAndCenters(List.of(member("field", MemberRole.FIELD), member("external1", MemberRole.EXTERNAL), member("external2", MemberRole.EXTERNAL), member("external3", MemberRole.EXTERNAL)), List.of(center("c1"), center("c2"), center("c3"))); PairingCandidates candidates = PairingCandidates.builder().pairCandidates(List.of(PairCandidate.builder().fieldMemberId("field").externalMemberId("external1").build(), PairCandidate.builder().fieldMemberId("field").externalMemberId("external2").build(), PairCandidate.builder().fieldMemberId("field").externalMemberId("external3").build())).dispatchRegionCandidates(List.of()).assignmentCandidates(List.of(assignment("field", "external1", "c1", "A", LocalDate.of(2026, 5, 1)), assignment("field", "external2", "c2", "A", LocalDate.of(2026, 5, 2)), assignment("field", "external3", "c3", "A", LocalDate.of(2026, 5, 3)))).build(); PairingResult result = service.solve(data, candidates); Map counterpartCounts = (Map)result.getAssignments().stream().collect(Collectors.groupingBy((assignment) -> assignment.getExternalMemberId(), Collectors.counting())); - Assertions.assertThat(result.getAssignments()).hasSize(2); - Assertions.assertThat(counterpartCounts).hasSize(2); + Assertions.assertThat(result.getAssignments()).hasSize(3); + Assertions.assertThat(counterpartCounts).hasSize(3); } @Test @@ -65,7 +65,7 @@ class PairingSolverServiceTest { PairingSolverService.SolveSelection selection = service.select(candidates, Map.of("field", Set.of("external1"), "external1", Set.of("field"))); - Assertions.assertThat(selection.selectedAssignments()).hasSize(2); + Assertions.assertThat(selection.selectedAssignments()).hasSize(3); Assertions.assertThat(selection.selectedAssignments()) .extracting(AssignmentCandidate::getExternalMemberId) .contains("external1"); diff --git a/src/test/java/com/kri/p6/ncrc/pairing/service/PairingTestSupport.java b/src/test/java/com/kri/p6/ncrc/pairing/service/PairingTestSupport.java index d818174..ea004f8 100644 --- a/src/test/java/com/kri/p6/ncrc/pairing/service/PairingTestSupport.java +++ b/src/test/java/com/kri/p6/ncrc/pairing/service/PairingTestSupport.java @@ -7,6 +7,8 @@ final class PairingTestSupport { } static PairingProperties pairingProperties() { - return new PairingProperties(); + PairingProperties properties = new PairingProperties(); + properties.getSolver().setMaxTimeSeconds(0.5); + return properties; } }