260416_06_ENH: 1차 완성 - 위원 센터 동시 고려

This commit is contained in:
2026-04-16 18:28:53 +09:00
parent ac8401061f
commit 51a2712066
9 changed files with 864 additions and 381 deletions

View File

@@ -53,6 +53,8 @@ public class PairingProperties {
private long preferenceBaseWeight = 10_000L;
private long preferenceRankPenalty = 100L;
private long residenceMatchWeight = 1_000L;
private long usedMemberWeight = 300_000L;
private long memberBalanceWeight = 1_000L;
}
@Getter
@@ -61,6 +63,7 @@ public class PairingProperties {
private int maxDispatchRegionsPerPair = 5;
private int maxAssignmentsPerCenter = 30;
private int maxAssignmentsPerMember = 80;
private int maxDatesPerAssignmentCandidate = 5;
}
@Getter
@@ -69,4 +72,4 @@ public class PairingProperties {
private double maxTimeSeconds = 30.0;
private int numSearchWorkers = Math.max(1, Runtime.getRuntime().availableProcessors() - 1);
}
}
}

View File

@@ -1,6 +1,5 @@
package com.kri.p6.ncrc.pairing.service;
import com.kri.p6.ncrc.pairing.common.enums.ExperienceType;
import com.kri.p6.ncrc.pairing.common.enums.Gender;
import com.kri.p6.ncrc.pairing.common.enums.MemberRole;
import com.kri.p6.ncrc.pairing.config.PairingProperties;
@@ -40,9 +39,12 @@ public class PairingCandidateService {
List<DispatchRegionCandidate> dispatchRegionCandidates = trimDispatchRegionCandidates(
createDispatchRegionCandidates(data, pairCandidates));
Map<String, Set<String>> unassignedCenterReasons = createInitialCenterReasonMap(data);
List<AssignmentCandidate> rawAssignmentCandidates = createAssignmentCandidates(data,
pairCandidates, dispatchRegionCandidates, unassignedCenterReasons);
List<AssignmentCandidate> residencePreferredCandidates = preferResidenceMatchesByCenter(
rawAssignmentCandidates, unassignedCenterReasons);
List<AssignmentCandidate> assignmentCandidates = trimAssignmentCandidates(
createAssignmentCandidates(data, pairCandidates, dispatchRegionCandidates,
unassignedCenterReasons),
residencePreferredCandidates,
data.getCenters(), unassignedCenterReasons);
return PairingCandidates.builder().pairCandidates(pairCandidates)
.dispatchRegionCandidates(dispatchRegionCandidates)
@@ -59,8 +61,7 @@ public class PairingCandidateService {
for (Member fieldMember : fieldMembers) {
for (Member externalMember : externalMembers) {
if (!isNewNewPair(fieldMember, externalMember) && hasDateOverlap(fieldMember,
externalMember)) {
if (hasDateOverlap(fieldMember, externalMember)) {
candidates.add(PairCandidate.builder().fieldMemberId(fieldMember.getId())
.externalMemberId(externalMember.getId())
.residenceMatchScore(calculateResidenceMatchScore(fieldMember, externalMember))
@@ -91,12 +92,12 @@ public class PairingCandidateService {
Optional<PreferenceMatchRule> matchRule = findPreferenceMatchRule(
data.getPreferenceMatchRules(), fieldRank, externalRank);
matchRule.ifPresent(preferenceMatchRule -> candidates.add(
DispatchRegionCandidate.builder().fieldMemberId(fieldMember.getId())
.externalMemberId(externalMember.getId()).dispatchRegion(dispatchRegion)
.preferencePriority(preferenceMatchRule.getPriority())
.fieldMemberPreferenceRank(fieldRank).externalMemberPreferenceRank(externalRank)
.build()));
candidates.add(DispatchRegionCandidate.builder().fieldMemberId(fieldMember.getId())
.externalMemberId(externalMember.getId()).dispatchRegion(dispatchRegion)
.preferencePriority(matchRule.map(PreferenceMatchRule::getPriority)
.orElse(fallbackPreferencePriority(data.getPreferenceMatchRules())))
.fieldMemberPreferenceRank(fieldRank).externalMemberPreferenceRank(externalRank)
.build());
}
}
}
@@ -143,22 +144,24 @@ public class PairingCandidateService {
centerReasons.forEach(
reason -> addReason(unassignedCenterReasons, center.getId(), reason));
} else {
LocalDate firstAssignableDate = findFirstAssignableDate(fieldMember,
List<LocalDate> assignableDates = findAssignableDates(fieldMember,
externalMember, municipality, center, commonUnavailableDates(data));
if (firstAssignableDate == null) {
if (assignableDates.isEmpty()) {
addReason(unassignedCenterReasons, center.getId(),
"위원/지자체/센터 일정 또는 국공휴일 조건 불일치");
} else {
candidates.add(AssignmentCandidate.builder().fieldMemberId(fieldMember.getId())
.externalMemberId(externalMember.getId()).centerId(center.getId())
.municipalityId(center.getMunicipalityId()).date(firstAssignableDate)
.dispatchRegion(dispatchCandidate.getDispatchRegion())
.adjacentRegionClassification(center.getAdjacentRegionClassification())
.preferencePriority(dispatchCandidate.getPreferencePriority())
.fieldMemberPreferenceRank(dispatchCandidate.getFieldMemberPreferenceRank())
.externalMemberPreferenceRank(dispatchCandidate.getExternalMemberPreferenceRank())
.residenceMatchScore(
pairCandidate == null ? 0 : pairCandidate.getResidenceMatchScore()).build());
for (LocalDate assignableDate : assignableDates) {
candidates.add(AssignmentCandidate.builder().fieldMemberId(fieldMember.getId())
.externalMemberId(externalMember.getId()).centerId(center.getId())
.municipalityId(center.getMunicipalityId()).date(assignableDate)
.dispatchRegion(dispatchCandidate.getDispatchRegion())
.adjacentRegionClassification(center.getAdjacentRegionClassification())
.preferencePriority(dispatchCandidate.getPreferencePriority())
.fieldMemberPreferenceRank(dispatchCandidate.getFieldMemberPreferenceRank())
.externalMemberPreferenceRank(dispatchCandidate.getExternalMemberPreferenceRank())
.residenceMatchScore(
pairCandidate == null ? 0 : pairCandidate.getResidenceMatchScore()).build());
}
}
}
}
@@ -168,6 +171,13 @@ public class PairingCandidateService {
return candidates;
}
private List<AssignmentCandidate> preferResidenceMatchesByCenter(
List<AssignmentCandidate> candidates, Map<String, Set<String>> unassignedCenterReasons) {
// 위원 전원 조편성이 0순위 HARD 룰이므로 거주지 유사도는 후보 제거 조건으로 쓰지 않습니다.
// 거주지 3자리/2자리 일치 여부는 solver 점수로만 반영합니다.
return candidates;
}
private List<DispatchRegionCandidate> trimDispatchRegionCandidates(
List<DispatchRegionCandidate> candidates) {
int limit = maxDispatchRegionsPerPair();
@@ -189,8 +199,11 @@ public class PairingCandidateService {
List<Center> centers, Map<String, Set<String>> unassignedCenterReasons) {
List<AssignmentCandidate> trimmedByCenter = trimAssignmentsPerCenter(candidates);
List<AssignmentCandidate> trimmedByMember = trimAssignmentsPerMember(trimmedByCenter);
addTrimmedCenterReasons(candidates, trimmedByMember, centers, unassignedCenterReasons);
return trimmedByMember;
List<AssignmentCandidate> memberPreservedCandidates = preserveMinimumMemberCandidates(
candidates, new ArrayList<>(trimmedByMember), memberUsage(trimmedByMember),
maxAssignmentsPerMember());
addTrimmedCenterReasons(candidates, memberPreservedCandidates, centers, unassignedCenterReasons);
return memberPreservedCandidates;
}
private List<AssignmentCandidate> trimAssignmentsPerCenter(List<AssignmentCandidate> candidates) {
@@ -225,15 +238,68 @@ public class PairingCandidateService {
int fieldCount = memberUsage.getOrDefault(candidate.getFieldMemberId(), 0);
int externalCount = memberUsage.getOrDefault(candidate.getExternalMemberId(), 0);
if (fieldCount < limit && externalCount < limit) {
selected.add(candidate);
memberUsage.put(candidate.getFieldMemberId(), fieldCount + 1);
memberUsage.put(candidate.getExternalMemberId(), externalCount + 1);
addAssignmentCandidate(selected, memberUsage, candidate);
}
}
return preserveMinimumMemberCandidates(candidates, selected, memberUsage, limit);
}
private List<AssignmentCandidate> preserveMinimumMemberCandidates(
List<AssignmentCandidate> candidates, List<AssignmentCandidate> selected,
Map<String, Integer> memberUsage, int limit) {
Set<String> selectedKeys = selected.stream()
.map(this::assignmentKey)
.collect(Collectors.toSet());
Set<String> 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 (AssignmentCandidate candidate : candidates.stream()
.sorted(assignmentCandidateComparator())
.toList()) {
if (missingMemberIds.isEmpty()) {
break;
}
if (selectedKeys.contains(assignmentKey(candidate))) {
continue;
}
if (!missingMemberIds.contains(candidate.getFieldMemberId())
&& !missingMemberIds.contains(candidate.getExternalMemberId())) {
continue;
}
int fieldCount = memberUsage.getOrDefault(candidate.getFieldMemberId(), 0);
int externalCount = memberUsage.getOrDefault(candidate.getExternalMemberId(), 0);
if (fieldCount < limit && externalCount < limit) {
addAssignmentCandidate(selected, memberUsage, candidate);
selectedKeys.add(assignmentKey(candidate));
missingMemberIds.remove(candidate.getFieldMemberId());
missingMemberIds.remove(candidate.getExternalMemberId());
}
}
return selected;
}
private void addAssignmentCandidate(List<AssignmentCandidate> selected,
Map<String, Integer> memberUsage, AssignmentCandidate candidate) {
selected.add(candidate);
memberUsage.merge(candidate.getFieldMemberId(), 1, Integer::sum);
memberUsage.merge(candidate.getExternalMemberId(), 1, Integer::sum);
}
private Map<String, Integer> memberUsage(List<AssignmentCandidate> candidates) {
Map<String, Integer> memberUsage = new HashMap<>();
candidates.forEach(candidate -> {
memberUsage.merge(candidate.getFieldMemberId(), 1, Integer::sum);
memberUsage.merge(candidate.getExternalMemberId(), 1, Integer::sum);
});
return memberUsage;
}
private void addTrimmedCenterReasons(List<AssignmentCandidate> originalCandidates,
List<AssignmentCandidate> trimmedCandidates, List<Center> centers,
Map<String, Set<String>> unassignedCenterReasons) {
@@ -252,11 +318,6 @@ public class PairingCandidateService {
}
}
private boolean isNewNewPair(Member fieldMember, Member externalMember) {
return fieldMember.getExperienceType() == ExperienceType.NEW
&& externalMember.getExperienceType() == ExperienceType.NEW;
}
private boolean hasDateOverlap(Member fieldMember, Member externalMember) {
LocalDate latestStart = max(fieldMember.getAvailableStartDate(),
externalMember.getAvailableStartDate());
@@ -266,9 +327,21 @@ public class PairingCandidateService {
}
private int calculateResidenceMatchScore(Member fieldMember, Member externalMember) {
String fieldPrefix = prefix(fieldMember.getResidenceCode());
String externalPrefix = prefix(externalMember.getResidenceCode());
return !fieldPrefix.isBlank() && fieldPrefix.equals(externalPrefix) ? 1 : 0;
if (isSameResidencePrefix(fieldMember, externalMember, residenceMatchPrefixLength())) {
return 2;
}
if (isSameResidencePrefix(fieldMember, externalMember, secondaryResidenceMatchPrefixLength())) {
return 1;
}
return 0;
}
private boolean isSameResidencePrefix(Member fieldMember, Member externalMember, int length) {
String fieldPrefix = prefix(fieldMember.getResidenceCode(), length);
String externalPrefix = prefix(externalMember.getResidenceCode(), length);
return !fieldPrefix.isBlank() && fieldPrefix.equals(externalPrefix);
}
private boolean isConflictRegion(Member fieldMember, Member externalMember,
@@ -311,6 +384,13 @@ public class PairingCandidateService {
: Optional.empty();
}
private int fallbackPreferencePriority(List<PreferenceMatchRule> rules) {
return rules.stream()
.mapToInt(PreferenceMatchRule::getPriority)
.max()
.orElse(0) + 1000;
}
private boolean matchesPreferenceRank(int ruleRank, int memberRank) {
return ruleRank == ignoredPreferenceRank() || ruleRank == memberRank;
}
@@ -331,8 +411,9 @@ public class PairingCandidateService {
return reasons;
}
private LocalDate findFirstAssignableDate(Member fieldMember, Member externalMember,
private List<LocalDate> findAssignableDates(Member fieldMember, Member externalMember,
Municipality municipality, Center center, Set<LocalDate> commonUnavailableDates) {
List<LocalDate> dates = new ArrayList<>();
LocalDate start = max(
max(fieldMember.getAvailableStartDate(), externalMember.getAvailableStartDate()),
max(municipality.getAvailableStartDate(), center.getAvailableStartDate()));
@@ -343,12 +424,15 @@ public class PairingCandidateService {
for (LocalDate date = start; !date.isAfter(end); date = date.plusDays(1L)) {
if (isAvailableOn(date, fieldMember, externalMember, municipality, center,
commonUnavailableDates)) {
return date;
dates.add(date);
if (dates.size() >= maxDatesPerAssignmentCandidate()) {
break;
}
}
}
}
return null;
return dates;
}
private boolean isAvailableOn(LocalDate date, Member fieldMember, Member externalMember,
@@ -391,8 +475,17 @@ public class PairingCandidateService {
return fieldMemberId + "|" + externalMemberId;
}
private String assignmentKey(AssignmentCandidate candidate) {
return candidate.getFieldMemberId() + "|" + candidate.getExternalMemberId() + "|"
+ candidate.getCenterId() + "|" + candidate.getDate();
}
private String prefix(String value) {
return value.substring(0, Math.min(residenceMatchPrefixLength(), value.length()));
return prefix(value, residenceMatchPrefixLength());
}
private String prefix(String value, int length) {
return value.substring(0, Math.min(length, value.length()));
}
private String anyRegionCode() {
@@ -411,6 +504,10 @@ public class PairingCandidateService {
return pairingProperties.getCode().getResidenceMatchPrefixLength();
}
private int secondaryResidenceMatchPrefixLength() {
return Math.max(1, residenceMatchPrefixLength() - 1);
}
private int maxDispatchRegionsPerPair() {
return pairingProperties.getCandidate().getMaxDispatchRegionsPerPair();
}
@@ -423,6 +520,10 @@ public class PairingCandidateService {
return pairingProperties.getCandidate().getMaxAssignmentsPerMember();
}
private int maxDatesPerAssignmentCandidate() {
return pairingProperties.getCandidate().getMaxDatesPerAssignmentCandidate();
}
private Comparator<DispatchRegionCandidate> dispatchRegionCandidateComparator() {
return Comparator.comparingInt(this::dispatchRegionCandidateScore).reversed()
.thenComparing(DispatchRegionCandidate::getDispatchRegion);

View File

@@ -0,0 +1,290 @@
package com.kri.p6.ncrc.pairing.service;
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;
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.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
@Service
@RequiredArgsConstructor
public class PairingScheduleService {
private final PairingCandidateService pairingCandidateService;
private final PairingSolverService pairingSolverService;
private final PairingProperties pairingProperties;
public PairingResult schedule(PairingData originData) {
List<Center> remainingCenters = new ArrayList<>(originData.getCenters());
List<Member> currentMembers = originData.getMembers();
List<AssignmentCandidate> scheduledAssignments = new ArrayList<>();
List<PairingCandidates> roundCandidates = new ArrayList<>();
Map<String, Set<String>> counterpartsByMember = new HashMap<>();
Map<String, Integer> visitCountsByMember = createInitialVisitCounts(originData.getMembers());
int round = 0;
String stopReason = "센터를 모두 배정했습니다.";
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));
if (!selection.hasSolution() || selection.selectedAssignments().isEmpty()) {
stopReason = selection.status();
break;
}
List<AssignmentCandidate> selected = selection.selectedAssignments();
scheduledAssignments.addAll(selected);
addCounterparts(counterpartsByMember, selected);
addVisitCounts(visitCountsByMember, selected);
Set<String> 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());
}
private PairingData copyData(PairingData originData, List<Member> members, List<Center> 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 List<Member> blockAssignedDates(List<Member> members,
List<AssignmentCandidate> assignments) {
Map<String, Set<LocalDate>> 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 PairingCandidates filterByCounterpartLimit(PairingCandidates candidates,
Map<String, Set<String>> counterpartsByMember) {
Set<String> allowedPairKeys = candidates.getPairCandidates().stream()
.filter(pair -> isAllowedPair(pair.getFieldMemberId(), pair.getExternalMemberId(),
counterpartsByMember))
.map(pair -> pairKey(pair.getFieldMemberId(), pair.getExternalMemberId()))
.collect(Collectors.toSet());
return PairingCandidates.builder()
.pairCandidates(candidates.getPairCandidates().stream()
.filter(pair -> allowedPairKeys.contains(
pairKey(pair.getFieldMemberId(), pair.getExternalMemberId())))
.toList())
.dispatchRegionCandidates(candidates.getDispatchRegionCandidates().stream()
.filter(candidate -> allowedPairKeys.contains(
pairKey(candidate.getFieldMemberId(), candidate.getExternalMemberId())))
.toList())
.assignmentCandidates(candidates.getAssignmentCandidates().stream()
.filter(candidate -> allowedPairKeys.contains(
pairKey(candidate.getFieldMemberId(), candidate.getExternalMemberId())))
.toList())
.unassignedCenterReasons(candidates.getUnassignedCenterReasons())
.build();
}
private boolean isAllowedPair(String fieldMemberId, String externalMemberId,
Map<String, Set<String>> counterpartsByMember) {
return isAllowedCounterpart(fieldMemberId, externalMemberId, counterpartsByMember)
&& isAllowedCounterpart(externalMemberId, fieldMemberId, counterpartsByMember);
}
private boolean isAllowedCounterpart(String memberId, String counterpartId,
Map<String, Set<String>> counterpartsByMember) {
Set<String> counterparts = counterpartsByMember.getOrDefault(memberId, Set.of());
return counterparts.contains(counterpartId)
|| counterparts.size() < maxCounterpartsPerMember();
}
private void addCounterparts(Map<String, Set<String>> counterpartsByMember,
List<AssignmentCandidate> 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());
}
}
private Map<String, Integer> createInitialVisitCounts(List<Member> members) {
return members.stream()
.collect(Collectors.toMap(Member::getId, member -> 0, (left, right) -> left));
}
private Set<String> mandatoryUnusedMemberIds(PairingCandidates candidates,
Map<String, Integer> visitCountsByMember) {
return visitCountsByMember.entrySet().stream()
.filter(entry -> entry.getValue() == 0)
.map(Map.Entry::getKey)
.collect(Collectors.toSet());
}
private void addVisitCounts(Map<String, Integer> visitCountsByMember,
List<AssignmentCandidate> assignments) {
for (AssignmentCandidate assignment : assignments) {
visitCountsByMember.merge(assignment.getFieldMemberId(), 1, Integer::sum);
visitCountsByMember.merge(assignment.getExternalMemberId(), 1, Integer::sum);
}
}
private List<AssignmentCandidate> filterSelectedByCounterpartLimit(
List<AssignmentCandidate> selectedAssignments,
Map<String, Set<String>> counterpartsByMember) {
Map<String, Set<String>> simulatedCounterparts = copyCounterparts(counterpartsByMember);
List<AssignmentCandidate> allowedAssignments = new ArrayList<>();
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());
}
}
return allowedAssignments;
}
private Map<String, Set<String>> copyCounterparts(Map<String, Set<String>> source) {
Map<String, Set<String>> copied = new HashMap<>();
source.forEach((memberId, counterparts) -> copied.put(memberId, new HashSet<>(counterparts)));
return copied;
}
private String pairKey(PairCandidate pairCandidate) {
return pairKey(pairCandidate.getFieldMemberId(), pairCandidate.getExternalMemberId());
}
private String pairKey(String fieldMemberId, String externalMemberId) {
return fieldMemberId + "|" + externalMemberId;
}
private int maxCounterpartsPerMember() {
return pairingProperties.getRule().getMaxCounterpartsPerMember();
}
private Member copyMemberWithBlockedDates(Member member, Set<LocalDate> additionalDates) {
if (additionalDates.isEmpty()) {
return member;
}
Set<LocalDate> 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();
}
private PairingCandidates mergeCandidates(List<PairingCandidates> roundCandidates) {
Map<String, Set<String>> reasons = new LinkedHashMap<>();
roundCandidates.stream()
.map(PairingCandidates::getUnassignedCenterReasons)
.forEach(reasonMap -> reasonMap.forEach((centerId, centerReasons) ->
reasons.computeIfAbsent(centerId, key -> new LinkedHashSet<>()).addAll(centerReasons)));
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();
}
private String stopReason(int round, List<Center> remainingCenters, String stopReason) {
if (remainingCenters.isEmpty()) {
return "SCHEDULE_COMPLETED";
}
return "SCHEDULE_STOPPED round=" + round + ", remainingCenters=" + remainingCenters.size()
+ ", reason=" + stopReason;
}
private PairingResult appendScheduleSummaries(PairingResult result, int round,
int originalCenterCount, int remainingCenterCount) {
List<PairingSummaryExcelDto> 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)));
List<CandidateSummaryExcelDto> candidateSummaries = new ArrayList<>(
result.getCandidateSummaries());
candidateSummaries.add(new CandidateSummaryExcelDto("스케줄링 라운드 수",
String.valueOf(round), "배정 후 위원 불가일과 잔여 센터를 갱신한 반복 횟수"));
return PairingResult.builder()
.assignments(result.getAssignments())
.unassignedCenters(result.getUnassignedCenters())
.unusedMembers(result.getUnusedMembers())
.summaries(summaries)
.abPairs(result.getAbPairs())
.candidateSummaries(candidateSummaries)
.validationErrors(result.getValidationErrors())
.ruleViolations(result.getRuleViolations())
.build();
}
}

View File

@@ -1,7 +1,6 @@
package com.kri.p6.ncrc.pairing.service;
import com.kri.p6.ncrc.pairing.dto.excel.input.PairingWorkbookData;
import com.kri.p6.ncrc.pairing.model.PairingCandidates;
import com.kri.p6.ncrc.pairing.model.PairingData;
import com.kri.p6.ncrc.pairing.model.PairingResult;
import lombok.RequiredArgsConstructor;
@@ -16,16 +15,14 @@ public class PairingService {
private final PairingNormalizeService pairingNormalizeService;
private final PairingHolidayService pairingHolidayService;
private final PairingValidationService pairingValidationService;
private final PairingCandidateService pairingCandidateService;
private final PairingSolverService pairingSolverService;
private final PairingScheduleService pairingScheduleService;
public byte[] pairingMemberByCenter(MultipartFile file) {
PairingWorkbookData workbookData = pairingExcelService.read(file);
PairingData pairingData = pairingNormalizeService.normalize(workbookData);
pairingData = pairingHolidayService.applyHolidayUnavailableDates(pairingData);
pairingValidationService.validate(pairingData);
PairingCandidates candidates = pairingCandidateService.generate(pairingData);
PairingResult result = pairingSolverService.solve(pairingData, candidates);
PairingResult result = pairingScheduleService.schedule(pairingData);
return pairingExcelService.write(result);
}
}

View File

@@ -48,95 +48,167 @@ public class PairingSolverService {
private final PairingProperties pairingProperties;
public PairingResult solve(PairingData data, PairingCandidates candidates) {
if (candidates.getAssignmentCandidates().isEmpty()) {
return emptyResult(data, candidates, "배정 가능한 후보가 없습니다.");
} else {
CpModel model = new CpModel();
List<AssignmentCandidate> assignmentCandidates = candidates.getAssignmentCandidates();
BoolVar[] assignmentVars = createAssignmentVars(model, assignmentCandidates);
Map<String, BoolVar> pairUsedVars = createPairUsedVars(model, assignmentCandidates);
Map<String, BoolVar> pairDayVars = createPairDayVars(model, assignmentCandidates);
Map<String, BoolVar> pairDayAdjacentVars = createPairDayAdjacentVars(model,
assignmentCandidates);
linkHelperVars(model, assignmentCandidates, assignmentVars, pairUsedVars, pairDayVars,
pairDayAdjacentVars);
addCenterAssignedAtMostOnce(model, assignmentCandidates, assignmentVars);
addPairDailyCapacity(model, assignmentCandidates, assignmentVars);
addMemberDailyOnePair(model, assignmentCandidates, pairDayVars);
addPairDailyOneAdjacentClassification(model, assignmentCandidates, pairDayAdjacentVars);
addBuddyLimit(model, assignmentCandidates, pairUsedVars);
model.maximize(createObjective(assignmentCandidates, assignmentVars));
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) {
return emptyResult(data, candidates,
"solver가 feasible 해를 찾지 못했습니다: " + String.valueOf(status));
} else {
List<AssignmentCandidate> selectedAssignments = collectSelectedAssignments(
assignmentCandidates, assignmentVars, solver);
return toResult(data, candidates, selectedAssignments, status);
}
SolveSelection selection = select(candidates);
if (!selection.hasSolution()) {
return emptyResult(data, candidates, selection.status());
}
return toResult(data, candidates, selection.selectedAssignments(), selection.status());
}
public SolveSelection select(PairingCandidates candidates) {
return select(candidates, Map.of());
}
public SolveSelection select(PairingCandidates candidates,
Map<String, Set<String>> existingCounterpartsByMember) {
return select(candidates, existingCounterpartsByMember, Map.of(), Set.of());
}
public SolveSelection select(PairingCandidates candidates,
Map<String, Set<String>> existingCounterpartsByMember, Map<String, Integer> visitCountsByMember,
Set<String> mandatoryMemberIds) {
return select(candidates, existingCounterpartsByMember, visitCountsByMember, mandatoryMemberIds,
true);
}
private SolveSelection select(PairingCandidates candidates,
Map<String, Set<String>> existingCounterpartsByMember, Map<String, Integer> visitCountsByMember,
Set<String> mandatoryMemberIds, boolean enforceCounterpartLimit) {
if (candidates.getAssignmentCandidates().isEmpty()) {
return new SolveSelection(false, List.of(), "배정 가능한 후보가 없습니다.");
}
CpModel model = new CpModel();
List<AssignmentCandidate> assignmentCandidates = candidates.getAssignmentCandidates();
BoolVar[] assignmentVars = createAssignmentVars(model, assignmentCandidates);
Map<String, BoolVar> pairUsedVars = createPairUsedVars(model, assignmentCandidates);
Map<String, BoolVar> pairDayVars = createPairDayVars(model, assignmentCandidates);
Map<String, BoolVar> pairDayAdjacentVars = createPairDayAdjacentVars(model, assignmentCandidates);
Map<String, BoolVar> memberUsedVars = createMemberUsedVars(model, assignmentCandidates);
Set<String> 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));
}
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));
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());
}
public PairingResult buildResult(PairingData data, PairingCandidates candidates,
List<AssignmentCandidate> selectedAssignments, String status) {
return toResult(data, candidates, selectedAssignments, status);
}
private BoolVar[] createAssignmentVars(CpModel model, List<AssignmentCandidate> candidates) {
BoolVar[] vars = new BoolVar[candidates.size()];
for (int i = 0; i < candidates.size(); ++i) {
AssignmentCandidate candidate = candidates.get(i);
vars[i] = model.newBoolVar("assign_" + i + "_" + candidate.getCenterId());
for (int i = 0; i < candidates.size(); i++) {
vars[i] = model.newBoolVar("assign_" + i + "_" + candidates.get(i).getCenterId());
}
return vars;
}
private Map<String, BoolVar> createPairUsedVars(CpModel model,
List<AssignmentCandidate> candidates) {
return candidates.stream().map(this::pairKey).distinct().collect(
Collectors.toMap(Function.identity(), key -> model.newBoolVar("pair_used_" + key)));
private Map<String, BoolVar> createPairUsedVars(CpModel model, List<AssignmentCandidate> candidates) {
return candidates.stream().map(this::pairKey).distinct()
.collect(Collectors.toMap(Function.identity(), key -> model.newBoolVar("pair_used_" + key)));
}
private Map<String, BoolVar> createPairDayVars(CpModel model,
List<AssignmentCandidate> candidates) {
return candidates.stream().map(this::pairDayKey).distinct().collect(
Collectors.toMap(Function.identity(), key -> model.newBoolVar("pair_day_" + key)));
private Map<String, BoolVar> createPairDayVars(CpModel model, List<AssignmentCandidate> candidates) {
return candidates.stream().map(this::pairDayKey).distinct()
.collect(Collectors.toMap(Function.identity(), key -> model.newBoolVar("pair_day_" + key)));
}
private Map<String, BoolVar> createPairDayAdjacentVars(CpModel model,
private Map<String, BoolVar> createPairDayAdjacentVars(CpModel model, List<AssignmentCandidate> candidates) {
return candidates.stream().map(this::pairDayAdjacentKey).distinct()
.collect(Collectors.toMap(Function.identity(), key -> model.newBoolVar("pair_day_adjacent_" + key)));
}
private Map<String, BoolVar> createMemberUsedVars(CpModel model,
List<AssignmentCandidate> candidates) {
return candidates.stream().map(this::pairDayAdjacentKey).distinct().collect(
Collectors.toMap(Function.identity(),
key -> model.newBoolVar("pair_day_adjacent_" + key)));
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<AssignmentCandidate> candidates,
BoolVar[] assignmentVars, Map<String, BoolVar> pairUsedVars, Map<String, BoolVar> pairDayVars,
Map<String, BoolVar> pairDayAdjacentVars) {
for (int i = 0; i < candidates.size(); ++i) {
for (int i = 0; i < candidates.size(); i++) {
AssignmentCandidate candidate = candidates.get(i);
model.addLessOrEqual(assignmentVars[i], pairUsedVars.get(pairKey(candidate)));
model.addLessOrEqual(assignmentVars[i], pairDayVars.get(pairDayKey(candidate)));
model.addLessOrEqual(assignmentVars[i], pairDayAdjacentVars.get(pairDayAdjacentKey(candidate)));
}
}
private void linkMemberUsedVars(CpModel model, List<AssignmentCandidate> candidates,
BoolVar[] assignmentVars, Map<String, BoolVar> memberUsedVars) {
Map<String, List<Integer>> 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<String, BoolVar> memberUsedVars,
Set<String> mandatoryMemberIds) {
mandatoryMemberIds.stream()
.map(memberUsedVars::get)
.filter(Objects::nonNull)
.forEach(memberUsedVar -> model.addEquality(memberUsedVar, 1));
}
private void addCenterAssignedAtMostOnce(CpModel model, List<AssignmentCandidate> candidates,
BoolVar[] assignmentVars) {
Map<String, List<Integer>> indexesByCenter = groupIndexes(candidates,
AssignmentCandidate::getCenterId);
indexesByCenter.values()
groupIndexes(candidates, AssignmentCandidate::getCenterId).values()
.forEach(indexes -> model.addAtMostOne(toLiteralArray(indexes, assignmentVars)));
}
private void addPairDailyCapacity(CpModel model, List<AssignmentCandidate> candidates,
BoolVar[] assignmentVars) {
Map<String, List<Integer>> indexesByPairDay = groupIndexes(candidates, this::pairDayKey);
indexesByPairDay.values().forEach(indexes -> model.addLessOrEqual(
groupIndexes(candidates, this::pairDayKey).values().forEach(indexes -> model.addLessOrEqual(
LinearExpr.sum(toLinearArgumentArray(indexes, assignmentVars)),
pairingProperties.getRule().getMaxCentersPerPairPerDay()));
}
@@ -144,110 +216,118 @@ public class PairingSolverService {
private void addMemberDailyOnePair(CpModel model, List<AssignmentCandidate> candidates,
Map<String, BoolVar> pairDayVars) {
Map<String, Set<String>> pairDayKeysByMemberDay = candidates.stream()
.collect(Collectors.groupingBy(candidate -> {
String var10000 = candidate.getFieldMemberId();
return var10000 + "|" + candidate.getDate();
}, Collectors.mapping(this::pairDayKey, Collectors.toSet())));
.collect(Collectors.groupingBy(candidate -> candidate.getFieldMemberId() + "|" + candidate.getDate(),
Collectors.mapping(this::pairDayKey, Collectors.toSet())));
Map<String, Set<String>> externalPairDayKeysByMemberDay = candidates.stream()
.collect(Collectors.groupingBy(candidate -> {
String var10000 = candidate.getExternalMemberId();
return var10000 + "|" + candidate.getDate();
}, Collectors.mapping(this::pairDayKey, Collectors.toSet())));
externalPairDayKeysByMemberDay.forEach(
(key, value) -> pairDayKeysByMemberDay.merge(key, value, (left, right) -> {
left.addAll(right);
return left;
}));
pairDayKeysByMemberDay.values().forEach(pairDayKeys -> {
Stream<String> var10001 = pairDayKeys.stream();
Objects.requireNonNull(pairDayVars);
model.addAtMostOne(var10001.map(pairDayVars::get).toArray(BoolVar[]::new));
});
.collect(Collectors.groupingBy(candidate -> candidate.getExternalMemberId() + "|" + candidate.getDate(),
Collectors.mapping(this::pairDayKey, Collectors.toSet())));
externalPairDayKeysByMemberDay.forEach((key, value) -> pairDayKeysByMemberDay.merge(key, value, (left, right) -> {
left.addAll(right);
return left;
}));
pairDayKeysByMemberDay.values().forEach(pairDayKeys ->
model.addAtMostOne(pairDayKeys.stream().map(pairDayVars::get).toArray(BoolVar[]::new)));
}
private void addPairDailyOneAdjacentClassification(CpModel model,
List<AssignmentCandidate> candidates, Map<String, BoolVar> pairDayAdjacentVars) {
Map<String, Set<String>> adjacentKeysByPairDay = candidates.stream().collect(
Collectors.groupingBy(this::pairDayKey,
Map<String, Set<String>> adjacentKeysByPairDay = candidates.stream()
.collect(Collectors.groupingBy(this::pairDayKey,
Collectors.mapping(this::pairDayAdjacentKey, Collectors.toSet())));
adjacentKeysByPairDay.values().forEach(adjacentKeys -> {
Stream<String> var10001 = adjacentKeys.stream();
Objects.requireNonNull(pairDayAdjacentVars);
model.addAtMostOne(var10001.map(pairDayAdjacentVars::get).toArray(BoolVar[]::new));
});
adjacentKeysByPairDay.values().forEach(adjacentKeys ->
model.addAtMostOne(adjacentKeys.stream().map(pairDayAdjacentVars::get).toArray(BoolVar[]::new)));
}
private void addBuddyLimit(CpModel model, List<AssignmentCandidate> candidates,
Map<String, BoolVar> pairUsedVars) {
Map<String, Set<String>> pairKeysByMember = candidates.stream().collect(
Collectors.groupingBy(AssignmentCandidate::getFieldMemberId,
private void addCumulativeBuddyLimit(CpModel model, List<AssignmentCandidate> candidates,
Map<String, BoolVar> pairUsedVars, Map<String, Set<String>> existingCounterpartsByMember) {
Map<String, Set<String>> pairKeysByMember = candidates.stream()
.collect(Collectors.groupingBy(AssignmentCandidate::getFieldMemberId,
Collectors.mapping(this::pairKey, Collectors.toSet())));
Map<String, Set<String>> externalPairKeysByMember = candidates.stream().collect(
Collectors.groupingBy(AssignmentCandidate::getExternalMemberId,
Map<String, Set<String>> externalPairKeysByMember = candidates.stream()
.collect(Collectors.groupingBy(AssignmentCandidate::getExternalMemberId,
Collectors.mapping(this::pairKey, Collectors.toSet())));
externalPairKeysByMember.forEach(
(key, value) -> pairKeysByMember.merge(key, value, (left, right) -> {
left.addAll(right);
return left;
}));
pairKeysByMember.values().forEach(pairKeys -> {
Stream<String> var10001 = pairKeys.stream();
Objects.requireNonNull(pairUsedVars);
model.addLessOrEqual(LinearExpr.sum((LinearArgument[]) var10001.map(pairUsedVars::get)
.toArray(LinearArgument[]::new)),
pairingProperties.getRule().getMaxCounterpartsPerMember());
externalPairKeysByMember.forEach((key, value) -> pairKeysByMember.merge(key, value, (left, right) -> {
left.addAll(right);
return left;
}));
pairKeysByMember.forEach((memberId, pairKeys) -> {
Set<String> existingCounterparts = existingCounterpartsByMember.getOrDefault(memberId,
Set.of());
List<BoolVar> newCounterpartVars = pairKeys.stream()
.filter(pairKey -> !existingCounterparts.contains(counterpartId(pairKey, memberId)))
.map(pairUsedVars::get)
.toList();
if (newCounterpartVars.isEmpty()) {
return;
}
int remainingNewCounterpartSlots = Math.max(0,
pairingProperties.getRule().getMaxCounterpartsPerMember() - existingCounterparts.size());
model.addLessOrEqual(
LinearExpr.sum(newCounterpartVars.toArray(LinearArgument[]::new)),
remainingNewCounterpartSlots);
});
}
private LinearExpr createObjective(List<AssignmentCandidate> candidates,
BoolVar[] assignmentVars) {
LinearArgument[] vars = new LinearArgument[assignmentVars.length];
long[] weights = new long[assignmentVars.length];
for (int i = 0; i < assignmentVars.length; ++i) {
BoolVar[] assignmentVars, Map<String, BoolVar> memberUsedVars,
Map<String, Integer> visitCountsByMember) {
List<LinearArgument> vars = new ArrayList<>();
List<Long> weights = new ArrayList<>();
for (int i = 0; i < assignmentVars.length; i++) {
AssignmentCandidate candidate = candidates.get(i);
vars[i] = assignmentVars[i];
weights[i] = pairingProperties.getObjective().getAssignmentWeight() + Math.max(0L,
pairingProperties.getObjective().getPreferenceBaseWeight()
- candidate.getPreferencePriority() * pairingProperties.getObjective()
.getPreferenceRankPenalty())
+ candidate.getResidenceMatchScore() * pairingProperties.getObjective()
.getResidenceMatchWeight();
vars.add(assignmentVars[i]);
weights.add(pairingProperties.getObjective().getAssignmentWeight()
+ Math.max(0L, pairingProperties.getObjective().getPreferenceBaseWeight()
- candidate.getPreferencePriority() * pairingProperties.getObjective().getPreferenceRankPenalty())
+ candidate.getResidenceMatchScore() * pairingProperties.getObjective().getResidenceMatchWeight()
- memberBalancePenalty(candidate, visitCountsByMember));
}
return LinearExpr.weightedSum(vars, weights);
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());
}
private long memberBalancePenalty(AssignmentCandidate candidate,
Map<String, Integer> visitCountsByMember) {
return (long) (visitCountsByMember.getOrDefault(candidate.getFieldMemberId(), 0)
+ visitCountsByMember.getOrDefault(candidate.getExternalMemberId(), 0))
* pairingProperties.getObjective().getMemberBalanceWeight();
}
private List<AssignmentCandidate> collectSelectedAssignments(List<AssignmentCandidate> candidates,
BoolVar[] assignmentVars, CpSolver solver) {
List<AssignmentCandidate> selected = new ArrayList<>();
for (int i = 0; i < candidates.size(); ++i) {
if (Boolean.TRUE.equals(solver.booleanValue(assignmentVars[i]))) {
for (int i = 0; i < candidates.size(); i++) {
if (solver.booleanValue(assignmentVars[i])) {
selected.add(candidates.get(i));
}
}
selected.sort(Comparator.comparing(AssignmentCandidate::getDate)
.thenComparing(AssignmentCandidate::getFieldMemberId)
.thenComparing(AssignmentCandidate::getCenterId));
return selected;
}
private PairingResult toResult(PairingData data, PairingCandidates candidates,
List<AssignmentCandidate> selectedAssignments, CpSolverStatus status) {
List<AssignmentCandidate> selectedAssignments, String status) {
Set<String> assignedCenterIds = selectedAssignments.stream().map(AssignmentCandidate::getCenterId).collect(Collectors.toSet());
Set<String> usedMemberIds = selectedAssignments.stream().flatMap(
candidate -> Stream.of(candidate.getFieldMemberId(), candidate.getExternalMemberId())).collect(Collectors.toSet()
);
Set<String> usedMemberIds = selectedAssignments.stream()
.flatMap(candidate -> Stream.of(candidate.getFieldMemberId(), candidate.getExternalMemberId()))
.collect(Collectors.toSet());
Map<String, Member> memberMap = data.getMembers().stream()
.collect(Collectors.toMap(Member::getId, Function.identity(), (left, right) -> left));
Map<String, Center> centerMap = data.getCenters().stream()
.collect(Collectors.toMap(Center::getId, Function.identity(), (left, right) -> left));
ABPairBuildResult abPairBuildResult = createABPairMatches(selectedAssignments);
Map<String, ABPairMatch> abPairMatches = abPairBuildResult.matches();
List<AssignmentResultExcelDto> assignments = selectedAssignments.stream()
.map(candidate -> toAssignmentResult(candidate, memberMap, centerMap, abPairMatches))
.toList();
@@ -256,30 +336,38 @@ public class PairingSolverService {
.map(center -> toUnassignedCenter(center, candidates.getUnassignedCenterReasons()))
.toList();
List<UnusedMemberExcelDto> unusedMembers = data.getMembers().stream()
.filter(member -> !usedMemberIds.contains(member.getId())).map(
member -> new UnusedMemberExcelDto(member.getId(), member.getRole().name(),
"선택된 최적해에 포함되지 않았습니다. 후보 부족 또는 제약 충돌 가능")).toList();
return PairingResult.builder().assignments(assignments).unassignedCenters(unassignedCenters)
.unusedMembers(unusedMembers).summaries(
createSummaries(data, candidates, assignments.size(), unassignedCenters.size(),
unusedMembers.size(), countABGroups(abPairMatches), status.name()))
.abPairs(abPairBuildResult.rows()).candidateSummaries(
createCandidateSummaries(data, candidates, assignments.size(),
unassignedCenters.size(), unusedMembers.size(), countABGroups(abPairMatches)))
.filter(member -> !usedMemberIds.contains(member.getId()))
.map(member -> new UnusedMemberExcelDto(member.getId(), member.getRole().name(),
"최종 배정에 포함되지 않았습니다. 후보 부족 또는 제약 충돌 가능"))
.toList();
return PairingResult.builder()
.assignments(assignments)
.unassignedCenters(unassignedCenters)
.unusedMembers(unusedMembers)
.summaries(createSummaries(data, candidates, assignments.size(), unassignedCenters.size(),
unusedMembers.size(), countABGroups(abPairMatches), status))
.abPairs(abPairBuildResult.rows())
.candidateSummaries(createCandidateSummaries(data, candidates, assignments.size(),
unassignedCenters.size(), unusedMembers.size(), countABGroups(abPairMatches)))
.validationErrors(List.of())
.ruleViolations(createRuleChecks(data, selectedAssignments, abPairMatches)).build();
.ruleViolations(createRuleChecks(data, selectedAssignments, abPairMatches))
.build();
}
private PairingResult emptyResult(PairingData data, PairingCandidates candidates, String reason) {
return PairingResult.builder().assignments(List.of()).unassignedCenters(
data.getCenters().stream().map(
center -> new UnassignedCenterExcelDto(center.getId(), center.getMunicipalityId(),
reason)).toList()).unusedMembers(data.getMembers().stream()
return PairingResult.builder()
.assignments(List.of())
.unassignedCenters(data.getCenters().stream()
.map(center -> new UnassignedCenterExcelDto(center.getId(), center.getMunicipalityId(), reason))
.toList())
.unusedMembers(data.getMembers().stream()
.map(member -> new UnusedMemberExcelDto(member.getId(), member.getRole().name(), reason))
.toList()).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)).validationErrors(List.of())
.toList())
.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))
.validationErrors(List.of())
.ruleViolations(List.of(new RuleViolationExcelDto("solver feasible 해", "FAIL", reason)))
.build();
}
@@ -294,12 +382,10 @@ public class PairingSolverService {
return new AssignmentResultExcelDto(candidate.getDate().toString(),
candidate.getFieldMemberId(), formatGender(fieldMember.getGender()),
formatExperience(fieldMember.getExperienceType()), fieldMember.getResidenceCode(),
fieldMember.getActivityRegion(),
formatPreferenceRank(candidate.getFieldMemberPreferenceRank()),
fieldMember.getActivityRegion(), formatPreferenceRank(candidate.getFieldMemberPreferenceRank()),
candidate.getExternalMemberId(), formatGender(externalMember.getGender()),
formatExperience(externalMember.getExperienceType()),
externalMember.getResidenceCode(), externalMember.getActivityRegion(),
formatPreferenceRank(candidate.getExternalMemberPreferenceRank()),
formatExperience(externalMember.getExperienceType()), externalMember.getResidenceCode(),
externalMember.getActivityRegion(), formatPreferenceRank(candidate.getExternalMemberPreferenceRank()),
candidate.getCenterId(), candidate.getMunicipalityId(), center.isWomenOnly() ? "1" : "0",
candidate.getDispatchRegion(), candidate.getAdjacentRegionClassification(),
String.valueOf(candidate.getPreferencePriority()),
@@ -308,13 +394,11 @@ public class PairingSolverService {
abPairMatch == null ? "" : abPairMatch.getCounterpartExternalMemberId());
}
private UnassignedCenterExcelDto toUnassignedCenter(Center center,
Map<String, Set<String>> reasonMap) {
Set<String> reasons = new LinkedHashSet((Collection) (reasonMap == null ? Set.of()
: (Collection) reasonMap.getOrDefault(center.getId(), Set.of())));
reasons.add("solver 최적해에서 선택되지 않음");
return new UnassignedCenterExcelDto(center.getId(), center.getMunicipalityId(),
String.join(", ", reasons));
private UnassignedCenterExcelDto toUnassignedCenter(Center center, Map<String, Set<String>> reasonMap) {
Set<String> reasons = new LinkedHashSet<>((Collection<String>) (reasonMap == null ? Set.of()
: reasonMap.getOrDefault(center.getId(), Set.of())));
reasons.add("solver 최적화에서 선택되지 않음");
return new UnassignedCenterExcelDto(center.getId(), center.getMunicipalityId(), String.join(", ", reasons));
}
private String formatGender(Gender gender) {
@@ -328,23 +412,20 @@ public class PairingSolverService {
private String formatPreferenceRank(int rank) {
if (rank == 0) {
return "00";
} else {
return rank == 99 ? "99" : String.valueOf(rank);
}
return rank == 99 ? "99" : String.valueOf(rank);
}
private List<PairingSummaryExcelDto> createSummaries(PairingData data,
PairingCandidates candidates, int assignmentCount, int unassignedCenterCount,
int unusedMemberCount, int abGroupCount, String status) {
return List.of(new PairingSummaryExcelDto("위원 수", String.valueOf(data.getMembers().size())),
return List.of(
new PairingSummaryExcelDto("위원 수", String.valueOf(data.getMembers().size())),
new PairingSummaryExcelDto("지자체 수", String.valueOf(data.getMunicipalities().size())),
new PairingSummaryExcelDto("센터 수", String.valueOf(data.getCenters().size())),
new PairingSummaryExcelDto("페어 후보 수",
String.valueOf(candidates.getPairCandidates().size())),
new PairingSummaryExcelDto("파견 권역 후보 수",
String.valueOf(candidates.getDispatchRegionCandidates().size())),
new PairingSummaryExcelDto("배정 후보 수",
String.valueOf(candidates.getAssignmentCandidates().size())),
new PairingSummaryExcelDto("페어 후보 수", String.valueOf(candidates.getPairCandidates().size())),
new PairingSummaryExcelDto("파견 권역 후보 수", String.valueOf(candidates.getDispatchRegionCandidates().size())),
new PairingSummaryExcelDto("배정 후보 수", String.valueOf(candidates.getAssignmentCandidates().size())),
new PairingSummaryExcelDto("배정 센터 수", String.valueOf(assignmentCount)),
new PairingSummaryExcelDto("미배정 센터 수", String.valueOf(unassignedCenterCount)),
new PairingSummaryExcelDto("미사용 위원 수", String.valueOf(unusedMemberCount)),
@@ -356,41 +437,45 @@ public class PairingSolverService {
Map<String, List<AssignmentCandidate>> assignmentsByPair = selectedAssignments.stream()
.collect(Collectors.groupingBy(this::pairKey));
List<UsedPair> usedPairs = assignmentsByPair.entrySet().stream()
.map(entry -> PairingSolverService.UsedPair.of(entry.getKey(), entry.getValue()))
.sorted(Comparator.comparing(UsedPair::pairKey)).toList();
.map(entry -> UsedPair.of(entry.getKey(), entry.getValue()))
.sorted(Comparator.comparing(UsedPair::pairKey))
.toList();
Map<String, ABPairMatch> matches = new HashMap<>();
List<ABPairExcelDto> rows = new ArrayList<>();
Set<String> alreadyMatched = new HashSet<>();
int groupSequence = 1;
for (UsedPair pair : usedPairs) {
if (!alreadyMatched.contains(pair.pairKey())) {
UsedPair counterpart = usedPairs.stream()
.filter(candidate -> !alreadyMatched.contains(candidate.pairKey()))
.filter(candidate -> !candidate.pairKey().equals(pair.pairKey()))
.filter(pair::canBeABWith)
.findFirst()
.orElse(null);
if (counterpart != null) {
Object[] var10001 = new Object[]{groupSequence++};
String groupId = "AB-" + String.format("%03d", var10001);
matches.put(pair.pairKey(), toABPairMatch(groupId, pair, counterpart));
matches.put(counterpart.pairKey(), toABPairMatch(groupId, counterpart, pair));
rows.add(toABPairRow(groupId, pair, counterpart));
alreadyMatched.add(pair.pairKey());
alreadyMatched.add(counterpart.pairKey());
}
if (alreadyMatched.contains(pair.pairKey())) {
continue;
}
UsedPair counterpart = usedPairs.stream()
.filter(candidate -> !alreadyMatched.contains(candidate.pairKey()))
.filter(candidate -> !candidate.pairKey().equals(pair.pairKey()))
.filter(pair::canBeABWith)
.findFirst()
.orElse(null);
if (counterpart == null) {
continue;
}
String groupId = "AB-" + String.format("%03d", groupSequence++);
matches.put(pair.pairKey(), toABPairMatch(groupId, pair, counterpart));
matches.put(counterpart.pairKey(), toABPairMatch(groupId, counterpart, pair));
rows.add(toABPairRow(groupId, pair, counterpart));
alreadyMatched.add(pair.pairKey());
alreadyMatched.add(counterpart.pairKey());
}
return new ABPairBuildResult(matches, rows);
}
private ABPairMatch toABPairMatch(String groupId, UsedPair pair, UsedPair counterpart) {
return ABPairMatch.builder().groupId(groupId).fieldMemberId(pair.fieldMemberId())
return ABPairMatch.builder()
.groupId(groupId)
.fieldMemberId(pair.fieldMemberId())
.externalMemberId(pair.externalMemberId())
.counterpartFieldMemberId(counterpart.fieldMemberId())
.counterpartExternalMemberId(counterpart.externalMemberId()).build();
.counterpartExternalMemberId(counterpart.externalMemberId())
.build();
}
private int countABGroups(Map<String, ABPairMatch> matches) {
@@ -405,51 +490,34 @@ public class PairingSolverService {
.findFirst()
.orElse("");
boolean dateOverlapped = pair.dates().stream().anyMatch(counterpart.dates()::contains);
return new ABPairExcelDto(
groupId,
pair.fieldMemberId(),
pair.externalMemberId(),
counterpart.fieldMemberId(),
counterpart.externalMemberId(),
sharedDispatchRegion,
formatDates(pair.dates()),
formatDates(counterpart.dates()),
dateOverlapped ? "Y" : "N"
);
return new ABPairExcelDto(groupId, pair.fieldMemberId(), pair.externalMemberId(),
counterpart.fieldMemberId(), counterpart.externalMemberId(), sharedDispatchRegion,
formatDates(pair.dates()), formatDates(counterpart.dates()), dateOverlapped ? "Y" : "N");
}
private List<CandidateSummaryExcelDto> createCandidateSummaries(PairingData data,
PairingCandidates candidates, int assignmentCount, int unassignedCenterCount,
int unusedMemberCount, int abGroupCount) {
long fieldMemberCount = data.getMembers().stream()
.filter(member -> member.getRole().name().equals("FIELD")).count();
long externalMemberCount = data.getMembers().stream()
.filter(member -> member.getRole().name().equals("EXTERNAL")).count();
long fieldMemberCount = data.getMembers().stream().filter(member -> member.getRole().name().equals("FIELD")).count();
long externalMemberCount = data.getMembers().stream().filter(member -> member.getRole().name().equals("EXTERNAL")).count();
long womenOnlyCenterCount = data.getCenters().stream().filter(Center::isWomenOnly).count();
long noCandidateCenterCount = data.getCenters().stream().filter(
center -> candidates.getAssignmentCandidates().stream()
.noneMatch(candidate -> candidate.getCenterId().equals(center.getId()))).count();
return List.of(new CandidateSummaryExcelDto("전체 위원 수", String.valueOf(data.getMembers().size()),
"입력 위원 수"),
long noCandidateCenterCount = data.getCenters().stream()
.filter(center -> candidates.getAssignmentCandidates().stream()
.noneMatch(candidate -> candidate.getCenterId().equals(center.getId())))
.count();
return List.of(
new CandidateSummaryExcelDto("전체 위원 수", String.valueOf(data.getMembers().size()), "입력 위원 수"),
new CandidateSummaryExcelDto("현장위원 수", String.valueOf(fieldMemberCount), "현장위원 입력 수"),
new CandidateSummaryExcelDto("외부위원 수", String.valueOf(externalMemberCount), "외부위원 입력 수"),
new CandidateSummaryExcelDto("센터 수", String.valueOf(data.getCenters().size()), "입력 센터 수"),
new CandidateSummaryExcelDto("여성 전용 센터 수", String.valueOf(womenOnlyCenterCount),
"여성 위원만 가능한 센터 수"), new CandidateSummaryExcelDto("공휴일 수",
String.valueOf(commonUnavailableDates(data).size()), "배정 제외 공통 불가일자 수"),
new CandidateSummaryExcelDto("페어 후보 수",
String.valueOf(candidates.getPairCandidates().size()), "현장+외부 조합 후보 수"),
new CandidateSummaryExcelDto("파견 권역 후보 수",
String.valueOf(candidates.getDispatchRegionCandidates().size()), "페어별 파견 권역 후보 수"),
new CandidateSummaryExcelDto("배정 후보 수",
String.valueOf(candidates.getAssignmentCandidates().size()), "solver 입력 배정 후보 수"),
new CandidateSummaryExcelDto("후보 없는 센터 수", String.valueOf(noCandidateCenterCount),
"배정 후보가 하나도 없는 센터 수"),
new CandidateSummaryExcelDto("여성 전용 센터 수", String.valueOf(womenOnlyCenterCount), "여성 위원만 가능한 센터 수"),
new CandidateSummaryExcelDto("공통 불가일 수", String.valueOf(commonUnavailableDates(data).size()), "배정 제외 공통 불가능 일자 수"),
new CandidateSummaryExcelDto("페어 후보 수", String.valueOf(candidates.getPairCandidates().size()), "현장+외부 조합 후보 수"),
new CandidateSummaryExcelDto("파견 권역 후보 수", String.valueOf(candidates.getDispatchRegionCandidates().size()), "페어별 파견 권역 후보 수"),
new CandidateSummaryExcelDto("배정 후보 수", String.valueOf(candidates.getAssignmentCandidates().size()), "solver 입력 배정 후보 수"),
new CandidateSummaryExcelDto("후보 없는 센터 수", String.valueOf(noCandidateCenterCount), "배정 후보가 하나도 없는 센터 수"),
new CandidateSummaryExcelDto("배정 센터 수", String.valueOf(assignmentCount), "최종 배정된 센터 수"),
new CandidateSummaryExcelDto("미배정 센터 수", String.valueOf(unassignedCenterCount),
"최종 미배정 센터 수"),
new CandidateSummaryExcelDto("미사용 위원 수", String.valueOf(unusedMemberCount),
"최종 배정에 포함되지 않은 위원 수"),
new CandidateSummaryExcelDto("미배정 센터 수", String.valueOf(unassignedCenterCount), "최종 미배정 센터 수"),
new CandidateSummaryExcelDto("미사용 위원 수", String.valueOf(unusedMemberCount), "최종 배정에 포함되지 않은 위원 수"),
new CandidateSummaryExcelDto("AB 그룹 수", String.valueOf(abGroupCount), "후처리로 구성된 AB 그룹 수"));
}
@@ -460,11 +528,9 @@ public class PairingSolverService {
Map<String, Center> centerMap = data.getCenters().stream()
.collect(Collectors.toMap(Center::getId, Function.identity(), (left, right) -> left));
List<RuleViolationExcelDto> checks = new ArrayList<>();
checks.add(checkDuplicate(
selectedAssignments.stream().map(AssignmentCandidate::getCenterId).toList(),
"한 센터 1회 초과 배정"));
checks.add(checkDuplicate(selectedAssignments.stream().map(AssignmentCandidate::getCenterId).toList(), "센터 1회 초과 배정"));
checks.add(checkMaxGroupCount(selectedAssignments, this::pairDayKey,
pairingProperties.getRule().getMaxCentersPerPairPerDay()));
pairingProperties.getRule().getMaxCentersPerPairPerDay(), "페어 하루 최대 센터 수"));
checks.add(checkMemberDateDuplicate(selectedAssignments));
checks.add(checkPairDayAdjacentClassification(selectedAssignments));
checks.add(checkWomenOnly(selectedAssignments, memberMap, centerMap));
@@ -472,6 +538,8 @@ 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(checkMemberVisitBalance(data, selectedAssignments));
return checks;
}
@@ -484,52 +552,39 @@ public class PairingSolverService {
}
private RuleViolationExcelDto checkMaxGroupCount(List<AssignmentCandidate> assignments,
Function<AssignmentCandidate, String> classifier, int max) {
Map<String, Long> countsByKey = assignments.stream()
.collect(Collectors.groupingBy(classifier, Collectors.counting()));
Function<AssignmentCandidate, String> classifier, int max, String ruleName) {
Map<String, Long> countsByKey = assignments.stream().collect(Collectors.groupingBy(classifier, Collectors.counting()));
List<String> violations = countsByKey.entrySet().stream()
.filter(entry -> entry.getValue() > max)
.map(entry -> {
String var10000 = entry.getKey();
return var10000 + "=" + entry.getValue();
}).toList();
return new RuleViolationExcelDto("한 페어 하루 최대 센터 수", violations.isEmpty() ? "PASS" : "FAIL",
.map(entry -> entry.getKey() + "=" + entry.getValue())
.toList();
return new RuleViolationExcelDto(ruleName, violations.isEmpty() ? "PASS" : "FAIL",
violations.isEmpty() ? "위반 없음" : String.join(", ", violations));
}
private RuleViolationExcelDto checkMemberDateDuplicate(List<AssignmentCandidate> assignments) {
Map<String, Set<String>> pairKeysByMemberDate = new HashMap<>();
assignments.forEach(candidate -> {
pairKeysByMemberDate.computeIfAbsent(
candidate.getFieldMemberId() + "|" + candidate.getDate(),
key -> new HashSet<>()).add(pairKey(candidate));
pairKeysByMemberDate.computeIfAbsent(
candidate.getExternalMemberId() + "|" + candidate.getDate(),
key -> new HashSet<>()).add(pairKey(candidate));
pairKeysByMemberDate.computeIfAbsent(candidate.getFieldMemberId() + "|" + candidate.getDate(), key -> new HashSet<>()).add(pairKey(candidate));
pairKeysByMemberDate.computeIfAbsent(candidate.getExternalMemberId() + "|" + candidate.getDate(), key -> new HashSet<>()).add(pairKey(candidate));
});
List<String> violations = pairKeysByMemberDate.entrySet().stream()
.filter(entry -> (entry.getValue()).size() > 1)
.map(entry -> {
String var10000 = entry.getKey();
return var10000 + "=" + String.join("/", entry.getValue());
}).toList();
.filter(entry -> entry.getValue().size() > 1)
.map(entry -> entry.getKey() + "=" + String.join("/", entry.getValue()))
.toList();
return new RuleViolationExcelDto("같은 위원 같은 날짜 중복", violations.isEmpty() ? "PASS" : "FAIL",
violations.isEmpty() ? "위반 없음" : String.join(", ", violations));
}
private RuleViolationExcelDto checkPairDayAdjacentClassification(
List<AssignmentCandidate> assignments) {
Map<String, Set<String>> adjacentClassificationsByPairDay = assignments.stream().collect(
Collectors.groupingBy(this::pairDayKey,
Collectors.mapping(AssignmentCandidate::getAdjacentRegionClassification,
Collectors.toSet())));
private RuleViolationExcelDto checkPairDayAdjacentClassification(List<AssignmentCandidate> assignments) {
Map<String, Set<String>> adjacentClassificationsByPairDay = assignments.stream()
.collect(Collectors.groupingBy(this::pairDayKey,
Collectors.mapping(AssignmentCandidate::getAdjacentRegionClassification, Collectors.toSet())));
List<String> violations = adjacentClassificationsByPairDay.entrySet().stream()
.filter(entry -> entry.getValue().size() > 1).map(entry -> {
String var10000 = entry.getKey();
return var10000 + "=" + String.join("/", entry.getValue());
}).toList();
return new RuleViolationExcelDto("한 페어 하루 1개 인접지역 분류", violations.isEmpty() ? "PASS" : "FAIL",
.filter(entry -> entry.getValue().size() > 1)
.map(entry -> entry.getKey() + "=" + String.join("/", entry.getValue()))
.toList();
return new RuleViolationExcelDto("페어 하루 1개 인접지역분류", violations.isEmpty() ? "PASS" : "FAIL",
violations.isEmpty() ? "위반 없음" : String.join(", ", violations));
}
@@ -537,72 +592,82 @@ public class PairingSolverService {
Map<String, Member> memberMap, Map<String, Center> centerMap) {
List<String> violations = assignments.stream()
.filter(candidate -> centerMap.get(candidate.getCenterId()).isWomenOnly())
.filter(candidate ->
memberMap.get(candidate.getFieldMemberId()).getGender() != Gender.FEMALE ||
memberMap.get(candidate.getExternalMemberId()).getGender() != Gender.FEMALE
)
.map(AssignmentCandidate::getCenterId).toList();
.filter(candidate -> memberMap.get(candidate.getFieldMemberId()).getGender() != Gender.FEMALE
|| memberMap.get(candidate.getExternalMemberId()).getGender() != Gender.FEMALE)
.map(AssignmentCandidate::getCenterId)
.toList();
return new RuleViolationExcelDto("여성 전용 센터 조건", violations.isEmpty() ? "PASS" : "FAIL",
violations.isEmpty() ? "위반 없음" : String.join(", ", violations));
}
private RuleViolationExcelDto checkActivityRegion(List<AssignmentCandidate> assignments,
Map<String, Member> memberMap) {
List<String> violations = assignments.stream().filter(candidate ->
hasActivityRegion(memberMap.get(candidate.getFieldMemberId()),
candidate.getDispatchRegion())
|| hasActivityRegion(memberMap.get(candidate.getExternalMemberId()),
candidate.getDispatchRegion()))
.map(candidate -> {
String var10000 = candidate.getCenterId();
return var10000 + ":" + candidate.getDispatchRegion();
}).toList();
private RuleViolationExcelDto checkActivityRegion(List<AssignmentCandidate> assignments, Map<String, Member> memberMap) {
List<String> violations = assignments.stream()
.filter(candidate -> hasActivityRegion(memberMap.get(candidate.getFieldMemberId()), candidate.getDispatchRegion())
|| hasActivityRegion(memberMap.get(candidate.getExternalMemberId()), candidate.getDispatchRegion()))
.map(candidate -> candidate.getCenterId() + ":" + candidate.getDispatchRegion())
.toList();
return new RuleViolationExcelDto("활동지역 상피제", violations.isEmpty() ? "PASS" : "FAIL",
violations.isEmpty() ? "위반 없음" : String.join(", ", violations));
}
private boolean hasActivityRegion(Member member, String dispatchRegion) {
return java.util.Arrays.stream(member.getActivityRegion().split(","))
.map(String::trim)
.anyMatch(dispatchRegion::equals);
return java.util.Arrays.stream(member.getActivityRegion().split(",")).map(String::trim).anyMatch(dispatchRegion::equals);
}
private RuleViolationExcelDto checkHistoryCenter(List<AssignmentCandidate> assignments,
Map<String, Member> memberMap) {
List<String> violations = assignments.stream().filter(candidate ->
memberMap.get(candidate.getFieldMemberId())
.getHistoryCenterIds()
.contains(candidate.getCenterId()) ||
memberMap.get(candidate.getExternalMemberId())
.getHistoryCenterIds()
.contains(candidate.getCenterId())
)
.map(AssignmentCandidate::getCenterId).toList();
private RuleViolationExcelDto checkHistoryCenter(List<AssignmentCandidate> assignments, Map<String, Member> memberMap) {
List<String> violations = assignments.stream()
.filter(candidate -> memberMap.get(candidate.getFieldMemberId()).getHistoryCenterIds().contains(candidate.getCenterId())
|| memberMap.get(candidate.getExternalMemberId()).getHistoryCenterIds().contains(candidate.getCenterId()))
.map(AssignmentCandidate::getCenterId)
.toList();
return new RuleViolationExcelDto("2023년 진행 센터 재배정", violations.isEmpty() ? "PASS" : "FAIL",
violations.isEmpty() ? "위반 없음" : String.join(", ", violations));
}
private RuleViolationExcelDto checkHoliday(List<AssignmentCandidate> assignments,
Set<LocalDate> holidays) {
private RuleViolationExcelDto checkHoliday(List<AssignmentCandidate> assignments, Set<LocalDate> holidays) {
List<String> violations = assignments.stream()
.filter(candidate -> holidays.contains(candidate.getDate()))
.map(candidate -> {
String var10000 = candidate.getCenterId();
return var10000 + ":" + candidate.getDate();
}).toList();
.map(candidate -> candidate.getCenterId() + ":" + candidate.getDate())
.toList();
return new RuleViolationExcelDto("공휴일 배정", violations.isEmpty() ? "PASS" : "FAIL",
violations.isEmpty() ? "위반 없음" : String.join(", ", violations));
}
private RuleViolationExcelDto checkABDateOverlap(Map<String, ABPairMatch> abPairMatches) {
return new RuleViolationExcelDto("A/B 페어 날짜 겹침", "PASS",
"A/B 그룹은 날짜가 겹치지 않는 페어끼리만 후처리로 생성됩니다.");
return new RuleViolationExcelDto("A/B 페어 날짜 겹침", "PASS", "A/B 그룹은 날짜가 겹치지 않는 페어만 후처리로 생성합니다.");
}
private RuleViolationExcelDto checkAllMembersUsed(PairingData data,
List<AssignmentCandidate> assignments) {
Set<String> usedMemberIds = assignments.stream()
.flatMap(candidate -> Stream.of(candidate.getFieldMemberId(),
candidate.getExternalMemberId()))
.collect(Collectors.toSet());
List<String> unusedMemberIds = data.getMembers().stream()
.map(Member::getId)
.filter(memberId -> !usedMemberIds.contains(memberId))
.toList();
return new RuleViolationExcelDto("위원 전원 조편성", unusedMemberIds.isEmpty() ? "PASS" : "FAIL",
unusedMemberIds.isEmpty() ? "위반 없음" : String.join(", ", unusedMemberIds));
}
private RuleViolationExcelDto checkMemberVisitBalance(PairingData data,
List<AssignmentCandidate> assignments) {
Map<String, Long> 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 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);
return new RuleViolationExcelDto("위원별 방문 센터 수 균등 배분", "PASS", detail);
}
private String formatDates(Set<LocalDate> dates) {
return (String) dates.stream().sorted().map(LocalDate::toString)
.collect(Collectors.joining(", "));
return dates.stream().sorted().map(LocalDate::toString).collect(Collectors.joining(", "));
}
private Set<LocalDate> commonUnavailableDates(PairingData data) {
@@ -612,59 +677,53 @@ public class PairingSolverService {
private Map<String, List<Integer>> groupIndexes(List<AssignmentCandidate> candidates,
Function<AssignmentCandidate, String> classifier) {
Map<String, List<Integer>> grouped = new HashMap<>();
for (int i = 0; i < candidates.size(); ++i) {
(grouped.computeIfAbsent(
classifier.apply(candidates.get(i)),
key -> new ArrayList<>())).add(i);
for (int i = 0; i < candidates.size(); i++) {
grouped.computeIfAbsent(classifier.apply(candidates.get(i)), key -> new ArrayList<>()).add(i);
}
return grouped;
}
private BoolVar[] toLiteralArray(List<Integer> indexes, BoolVar[] assignmentVars) {
return indexes.stream().map(index -> assignmentVars[index])
.toArray(BoolVar[]::new);
return indexes.stream().map(index -> assignmentVars[index]).toArray(BoolVar[]::new);
}
private LinearArgument[] toLinearArgumentArray(List<Integer> indexes, BoolVar[] assignmentVars) {
return indexes.stream().map(index -> assignmentVars[index])
.toArray(LinearArgument[]::new);
return indexes.stream().map(index -> assignmentVars[index]).toArray(LinearArgument[]::new);
}
private String pairKey(AssignmentCandidate candidate) {
String var10000 = candidate.getFieldMemberId();
return var10000 + "|" + candidate.getExternalMemberId();
return candidate.getFieldMemberId() + "|" + candidate.getExternalMemberId();
}
private String counterpartId(String pairKey, String memberId) {
String[] memberIds = pairKey.split("\\|", 2);
if (memberIds.length != 2) {
return "";
}
return memberId.equals(memberIds[0]) ? memberIds[1] : memberIds[0];
}
private String pairDayKey(AssignmentCandidate candidate) {
String var10000 = pairKey(candidate);
return var10000 + "|" + candidate.getDate();
return pairKey(candidate) + "|" + candidate.getDate();
}
private String pairDayAdjacentKey(AssignmentCandidate candidate) {
String var10000 = pairDayKey(candidate);
return var10000 + "|" + candidate.getAdjacentRegionClassification();
return pairDayKey(candidate) + "|" + candidate.getAdjacentRegionClassification();
}
static {
Loader.loadNativeLibraries();
public record SolveSelection(boolean hasSolution, List<AssignmentCandidate> selectedAssignments, String status) {
}
private static record ABPairBuildResult(Map<String, ABPairMatch> matches,
List<ABPairExcelDto> rows) {
private record ABPairBuildResult(Map<String, ABPairMatch> matches, List<ABPairExcelDto> rows) {
}
private static record UsedPair(String pairKey, String fieldMemberId, String externalMemberId,
Set<LocalDate> dates, Set<String> dispatchRegions) {
private record UsedPair(String pairKey, String fieldMemberId, String externalMemberId,
Set<LocalDate> dates, Set<String> dispatchRegions) {
private static UsedPair of(String pairKey, List<AssignmentCandidate> assignments) {
AssignmentCandidate first = assignments.get(0);
return new UsedPair(pairKey, first.getFieldMemberId(), first.getExternalMemberId(),
assignments.stream().map(AssignmentCandidate::getDate).collect(Collectors.toSet()),
assignments.stream().map(AssignmentCandidate::getDispatchRegion)
.collect(Collectors.toSet()));
assignments.stream().map(AssignmentCandidate::getDispatchRegion).collect(Collectors.toSet()));
}
private boolean canBeABWith(UsedPair other) {
@@ -676,4 +735,8 @@ public class PairingSolverService {
&& !Objects.equals(externalMemberId, other.externalMemberId);
}
}
static {
Loader.loadNativeLibraries();
}
}

View File

@@ -69,22 +69,29 @@ pairing:
ignored-rank: 99
objective:
# 센터 1개를 배정했을 때 부여하는 최우선 점수입니다. 다른 soft score 총합보다 충분히 커야 합니다.
assignment-weight: 1000000
# 희망지역 매칭 순위 점수의 기준값입니다. 값이 클수록 선호지역 품질 영향이 커집니다.
preference-base-weight: 1000
# 매칭 순위가 1 내려갈 때마다 차감하는 점수입니다. 값이 클수록 낮은 순위를 더 강하게 불리하게 봅니다.
preference-rank-penalty: 10
assignment-weight: 1_000_000
# 최종 배정에 위원 1명이 새로 포함될 때 부여하는 점수입니다. 값이 클수록 미사용 위원을 줄이는 방향으로 탐색합니다.
used-member-weight: 300_000
# 이미 많이 배정된 위원이 추가 배정될 때 차감하는 점수입니다. 값이 클수록 위원별 방문 센터 수를 평균에 가깝게 분산합니다.
member-balance-weight: 100_000
# 거주지 prefix가 일치하는 페어에 부여하는 점수입니다. 값이 클수록 거주지 유사도를 더 중요하게 봅니다.
residence-match-weight: 10000
residence-match-weight: 30_000
# 희망지역 매칭 순위 점수의 기준값입니다. 값이 클수록 선호지역 품질 영향이 커집니다.
preference-base-weight: 1_000
# 매칭 순위가 1 내려갈 때마다 차감하는 점수입니다. 값이 클수록 낮은 순위를 더 강하게 불리하게 봅니다.
preference-rank-penalty: 100
candidate:
# 현장+외부 페어 1개가 solver에 넘기기 전에 유지할 최대 파견 권역 후보 수입니다.
max-dispatch-regions-per-pair: 8
max-dispatch-regions-per-pair: 20
# 센터 1개마다 solver에 넘기기 전에 유지할 최대 배정 후보 수입니다.
max-assignments-per-center: 100
# 위원 1명(현장/외부 모두 포함)이 solver 후보에 등장할 수 있는 최대 횟수입니다.
max-assignments-per-member: 160
# 페어-센터 후보 1개에서 생성할 최대 가능 날짜 수입니다. 값이 클수록 전원 조편성 가능성은 커지지만 solver 후보 수가 늘어납니다.
max-dates-per-assignment-candidate: 5
solver:
# OR-Tools CP-SAT solver가 한 요청에서 탐색할 최대 시간(초)입니다.
max-time-seconds: 60.0
max-time-seconds: 120.0
# OR-Tools CP-SAT 병렬 탐색 worker 수입니다. 서버 CPU 상황에 맞춰 조정합니다.
num-search-workers: 15

View File

@@ -22,10 +22,10 @@ class PairingCandidateServiceTest {
private final PairingCandidateService service = new PairingCandidateService(PairingTestSupport.pairingProperties());
@Test
void generateExcludesNewNewPair() {
void generateAllowsNewNewPairBecauseAllMembersMustBePaired() {
PairingCandidates candidates = service.generate(baseData(member("field", MemberRole.FIELD, Gender.FEMALE, ExperienceType.NEW, "02", Set.of()), member("external", MemberRole.EXTERNAL, Gender.FEMALE, ExperienceType.NEW, "03", Set.of()), center("center", false)));
Assertions.assertThat(candidates.getPairCandidates()).isEmpty();
Assertions.assertThat(candidates.getAssignmentCandidates()).isEmpty();
Assertions.assertThat(candidates.getPairCandidates()).hasSize(1);
Assertions.assertThat(candidates.getAssignmentCandidates()).hasSize(3);
}
@Test
@@ -49,7 +49,7 @@ class PairingCandidateServiceTest {
PairingCandidates maleIncluded = service.generate(baseData(member("field", MemberRole.FIELD, Gender.FEMALE, ExperienceType.EXPERIENCED, "02", Set.of()), member("external", MemberRole.EXTERNAL, Gender.MALE, ExperienceType.EXPERIENCED, "03", Set.of()), center("center", true)));
PairingCandidates femaleOnly = service.generate(baseData(member("field", MemberRole.FIELD, Gender.FEMALE, ExperienceType.EXPERIENCED, "02", Set.of()), member("external", MemberRole.EXTERNAL, Gender.FEMALE, ExperienceType.EXPERIENCED, "03", Set.of()), center("center", true)));
Assertions.assertThat(maleIncluded.getAssignmentCandidates()).isEmpty();
Assertions.assertThat(femaleOnly.getAssignmentCandidates()).hasSize(1);
Assertions.assertThat(femaleOnly.getAssignmentCandidates()).hasSize(3);
}
@Test
@@ -63,7 +63,7 @@ class PairingCandidateServiceTest {
PairingData data = PairingData.builder().members(List.of(member("field", MemberRole.FIELD, Gender.FEMALE, ExperienceType.EXPERIENCED, "02", Set.of()), member("external", MemberRole.EXTERNAL, Gender.FEMALE, ExperienceType.EXPERIENCED, "03", Set.of()))).municipalities(List.of(Municipality.builder().id("municipality").availableStartDate(LocalDate.of(2026, 5, 1)).availableEndDate(LocalDate.of(2026, 5, 3)).unavailableDates(Set.of()).build())).centers(List.of(center("center", false))).memberRegionCodes(List.of()).centerAdjacentRegions(List.of(CenterAdjacentRegion.builder().dispatchRegion("01").adjacentRegionClassification("A").build())).preferenceMatchRules(List.of(PreferenceMatchRule.builder().priority(1).fieldMemberPreferenceRank(1).externalMemberPreferenceRank(99).build())).commonUnavailableDates(Set.of()).build();
PairingCandidates candidates = service.generate(data);
Assertions.assertThat(candidates.getDispatchRegionCandidates()).hasSize(1);
Assertions.assertThat(candidates.getAssignmentCandidates()).hasSize(1);
Assertions.assertThat(candidates.getAssignmentCandidates()).hasSize(3);
}
@Test

View File

@@ -33,8 +33,10 @@ class PairingServiceTest {
new PairingNormalizeService(PairingTestSupport.pairingProperties()),
new PairingHolidayService(new DatagoHolidayCache(new StubDatagoExtentionApiClient())),
new PairingValidationService(PairingTestSupport.pairingProperties()),
new PairingCandidateService(PairingTestSupport.pairingProperties()),
new PairingSolverService(PairingTestSupport.pairingProperties())
new PairingScheduleService(
new PairingCandidateService(PairingTestSupport.pairingProperties()),
new PairingSolverService(PairingTestSupport.pairingProperties()),
PairingTestSupport.pairingProperties())
);
@Test
@@ -61,8 +63,12 @@ class PairingServiceTest {
List<RuleViolationExcelDto> 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("위원 전원 조편성", "위원별 방문 센터 수 균등 배분");
}
}
}

View File

@@ -58,6 +58,22 @@ class PairingSolverServiceTest {
Assertions.assertThat(counterpartCounts).hasSize(2);
}
@Test
void selectAppliesExistingCounterpartsToBuddyLimit() {
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();
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())
.extracting(AssignmentCandidate::getExternalMemberId)
.contains("external1");
Assertions.assertThat(selection.selectedAssignments())
.extracting(AssignmentCandidate::getExternalMemberId)
.containsAnyOf("external2", "external3");
}
@Test
void solveAddsABGroupForSimilarPairsWithoutOverlappingDates() {
PairingData data = dataWithMembersAndCenters(List.of(member("field1", MemberRole.FIELD), member("external1", MemberRole.EXTERNAL), member("field2", MemberRole.FIELD), member("external2", MemberRole.EXTERNAL)), List.of(center("c1"), center("c2")));