ปัญหาทางธุรกิจ

✶ ปัญหาทางธุรกิจการหาช่วงเวลาที่มากที่สุดและน้อยที่สุดที่ลูกค้าเข้าใช้งาน Platform

คือกระบวนการวิเคราะห์ข้อมูลเวลาในการใช้งานของลูกค้าบนแพลตฟอร์ม โดยหาช่วงเวลาที่มีผู้ใช้งานมากที่สุดและน้อยที่สุด เพื่อวางแผนปรับปรุงระบบหรือกำหนดกลยุทธ์ทางธุรกิจให้มีประสิทธิภาพสูงสุด

ตัวอย่างการประยุกต์ใช้การหาช่วงเวลาที่มากที่สุดและน้อยที่สุดที่ลูกค้าเข้าใช้งาน Platform ในทางธุรกิจ

การหาช่วงเวลาที่มีผู้ใช้งานมากที่สุดและน้อยที่สุด สามารถประยุกต์ใช้ในหลากหลายด้านในทางธุรกิจเพื่อเพิ่มประสิทธิภาพ ลดต้นทุน ตัวอย่างที่สำคัญมีดังนี้

การบริหารเซิร์ฟเวอร์: ใช้ข้อมูลช่วงเวลาที่สูงที่สุดเพื่อจัดเตรียมทรัพยากรระบบให้เพียงพอ และใช้ช่วงเวลาช่วงที่ต่ำที่สุดเพื่อลดการใช้ทรัพยากร
การตลาดดิจิทัล: ใช้ช่วงเวลาที่ลูกค้าเข้าใช้งานมากที่สุดในการยิงโฆษณาหรือโปรโมชันเพื่อให้เข้าถึงลูกค้าได้มากที่สุด
การวิเคราะห์พฤติกรรมผู้ใช้: ศึกษาช่วงเวลาที่ลูกค้าใช้งานเยอะเพื่อเข้าใจลักษณะและพฤติกรรมการใช้งาน
การวางแผนโปรโมชั่น: วางแผนช่วงเวลาลดราคาให้ตรงกับเวลาที่ลูกค้าใช้งานมากที่สุด
การวางแผนกำลังคน: ใช้ข้อมูลเพื่อจัดสรรพนักงานให้เพียงพอในช่วงเวลาที่มีผู้ใช้งานหนาแน่น
ระบบแนะนำสินค้า: ปรับการแนะนำสินค้าให้เหมาะสมกับช่วงเวลาใช้งาน

ประโยชน์ของการใช้การหาช่วงเวลา Max และ Min ที่ลูกค้าใช้งาน Platform ในธุรกิจ

เพิ่มความสามารถในการวางแผนและบริหารทรัพยากร: เช่น การวางระบบเซิร์ฟเวอร์หรือบุคลากรให้สอดคล้องกับปริมาณผู้ใช้งาน
ลดต้นทุน: จากการบริหารจัดการที่ไม่จำเป็นในช่วงเวลาที่มีผู้ใช้งานน้อย
เพิ่มประสิทธิภาพการทำงานของระบบ: เช่น การโหลดหน้าเว็บไซต์หรือทำให้แอปให้เร็วขึ้นในช่วงที่มีผู้เข้าใช้งานมาก
ปรับแผนการตลาดให้ตรงจุด: เช่น ยิงโฆษณาในช่วงที่มีโอกาสถูกเห็นมากที่สุด
ช่วยในการวางแผนโปรโมชั่น: ส่งเสริมยอดขายในเวลาที่เหมาะสม

Algorithm ที่ใช้ในการเปรียบเทียบ

✶ การค้นหาแบบลำดับ (Sequential Search)

คือการค้นหาข้อมูลจากชุดข้อมูลทีละรายการเรียงลำดับไปอย่างต่อเนื่องจนกว่าจะพบข้อมูลที่ต้องการ โดยเริ่มจากข้อมูลตัวแรกแล้วตรวจสอบไปจนถึงตัวสุดท้าย หากไม่ตรงกับค่าที่ต้องการค้นหาก็จะดำเนินการค้นหาตัวถัดไป อัลกอริทึมนี้มีความเร็วในการค้นหาเป็น O(n) เมื่อ n คือจำนวนรายการทั้งหมดในชุดข้อมูล

จุดเด่นของวิธีนี้คือ:

ความง่ายในการใช้งาน ไม่จำเป็นต้องมีการจัดเรียงข้อมูลล่วงหน้า
เหมาะสำหรับข้อมูลขนาดเล็ก หรือเมื่อต้องการตรวจสอบข้อมูลแบบเรียลไทม์

ในการค้นหาช่วงเวลาที่สูงสุดและต่ำสุดที่ลูกค้าใช้งานบนแพลตฟอร์ม การค้นหาแบบลำดับสามารถนำมาใช้เพื่อค้นหาช่วงเวลาที่มีจำนวนผู้ใช้งานสูงสุดและต่ำสุดได้ โดยผลลัพธ์จากการค้นหาจะมี 2 กรณีด้วยกันคือ:

พบช่วงเวลาที่มีการใช้งานสูงสุด
พิจารณาจากตารางต่อไปนี้ ในรอบแรกเรากำหนดให้ช่วงเวลาที่ดัชนี 0 มีจำนวนการใช้งาน 4 เป็นช่วงเวลาที่มีการใช้งานสูงสุด และทำการเปรียบเทียบกับช่วงเวลาถัดไป หากพบว่าช่วงเวลาใดมีจำนวนการใช้งานมากกว่าช่วงเวลาที่ถูกบันทึกไว้ จะทำการปรับปรุงช่วงเวลาที่มีการใช้งานสูงสุดใหม่ ทำเช่นนี้วนไปเรื่อย ๆ จนกระทั่งพิจารณาทุกช่วงเวลาแล้ว เราก็จะพบช่วงเวลาที่มีการใช้งานสูงสุด

พบช่วงเวลาที่มีการใช้งานต่ำสุด
โดยในรอบแรกเรากำหนดให้ช่วงเวลาที่ดัชนี 0 มีจำนวนการใช้งาน 4 เป็นช่วงเวลาที่มีการใช้งานต่ำสุด และทำการเปรียบเทียบกับช่วงเวลาถัดไป หากพบว่าช่วงเวลาใดมีจำนวนการใช้งานน้อยกว่าช่วงเวลาที่ถูกบันทึกไว้ จะทำการปรับปรุงช่วงเวลาที่มีการใช้งานต่ำสุดใหม่ ทำเช่นนี้วนไปเรื่อย ๆ จนกระทั่งพิจารณาทุกช่วงเวลาแล้ว เราก็จะพบช่วงเวลาที่มีการใช้งานต่ำสุด

Code Algorithm ที่ใช้ในการเปรียบเทียบ


import numpy as np
import time
def get_time_range(idx, times):
    return times[idx]
dataset = []
times_large_from_file = []
with open("data-file.txt", 'r') as file:
    for line in file:
        time_str, user_count = line.strip().split(',')
        times_large_from_file.append(time_str)
        dataset.append(int(user_count))
times_large_from_file = np.array(times_large_from_file)
def sequential_search(users):
    max_value = users[0]
    min_value = users[0]
    max_index = 0
    min_index = 0
    for i in range(1, len(users)):
        if users[i] > max_value:
            max_value = users[i]
            max_index = i
        if users[i] < min_value:
            min_value = users[i]
            min_index = i
    return max_value, max_index, min_value, min_index
start_time = time.time()
seq_max, seq_max_idx, seq_min, seq_min_idx = sequential_search(dataset)
sequential_time = time.time() - start_time
print("ผลลัพธ์ Sequential Search:")
print(f"จำนวนผู้ใช้สูงสุด {seq_max} คน ช่วงเวลา {get_time_range(seq_max_idx, times_large_from_file)}")
print(f"จำนวนผู้ใช้น้อยสุด {seq_min} คน ช่วงเวลา {get_time_range(seq_min_idx, times_large_from_file)}")
print(f"ใช้เวลา: {sequential_time:.6f} วินาที\n")

Line	Code
1	import numpy as np
2	import time
3	def get_time_range(idx, times):
4	return times[idx]
5	dataset = []
6	times_large_from_file = []
7	with open("data-file.txt", 'r') as file:
8	for line in file:
9	time_str, user_count = line.strip().split(',')
10	times_large_from_file.append(time_str)
11	dataset.append(int(user_count))
12	times_large_from_file = np.array(times_large_from_file)
13	def sequential_search(users):
14	max_value = users[0]
15	min_value = users[0]
16	max_index = 0
17	min_index = 0
18	for i in range(1, len(users)):
19	if users[i] > max_value:
20	max_value = users[i]
21	max_index = i
22	if users[i] < min_value:
23	min_value = users[i]
24	min_index = i
25	return max_value, max_index, min_value, min_index
26	start_time = time.time()
27	seq_max, seq_max_idx, seq_min, seq_min_idx = sequential_search(dataset)
28	sequential_time = time.time() - start_time
29	print("ผลลัพธ์ Sequential Search:")
30	print(f"จำนวนผู้ใช้สูงสุด {seq_max} คน ช่วงเวลา {get_time_range(seq_max_idx, times_large_from_file)}")
31	print(f"จำนวนผู้ใช้น้อยสุด {seq_min} คน ช่วงเวลา {get_time_range(seq_min_idx, times_large_from_file)}")
32	print(f"ใช้เวลา: {sequential_time:.6f} วินาที\n")

Algorithm ที่นำเสนอ

✶ การแบ่งแยกและเอาชนะ (Divide and Conquer)

คือการแบ่งปัญหาออกเป็นส่วนย่อยที่มีขนาดเล็กลง แล้วทำการแก้ปัญหาย่อย จากนั้นจึงเปรียบเทียบผลลัพธ์จากแต่ละส่วนเพื่อหาคำตอบที่ดีที่สุด หลักการนี้จะช่วยลดจำนวนครั้งในการเปรียบเทียบและสามารถใช้ได้แม้ในข้อมูลขนาดใหญ่ที่มีความซับซ้อน โดยระยะเวลาที่ใช้ในการค้นหา คือ O(log2n) สำหรับข้อมูลจำนวนน้อยผลลัพธ์ที่ได้อาจจะไม่ต่างกัน แต่ถ้าข้อมูลจำนวนมากเช่น 1000 ตัว ถ้าใช้เปรียบเทียบด้วยขั้นตอนวิธีแบ่งแยกและเอาชนะ คือ 2 x log₂1000 = 20 ครั้ง แต่ถ้าใช้ การค้นหาแบบลำดับ เวลาที่ใช้ค้นหาจะเป็น n หรือ 1000 ซึ่งช้ากว่าขั้นตอนวิธีแบ่งแยกและเอาชนะ

หลักการทำงานแบบการแบ่งแยกและเอาชนะในการค้นหาค่ามากที่สุดและน้อยที่สุด

เริ่มต้นด้วยการแบ่งข้อมูลออกเป็น 2 ส่วนเท่าๆ กัน จนกระทั่งส่วนย่อยที่ได้มีขนาดเล็กที่สุด คือมีข้อมูลเพียง 1 หรือ 2 รายการเท่านั้น
1. ถ้ามี 1 รายการ: ค่าของข้อมูลนั้นคือทั้งค่ามากที่สุดและน้อยที่สุดของส่วนนั้น
2. ถ้ามี 2 รายการ: เปรียบเทียบค่าของทั้งสองรายการ ตัวที่มีค่ามากกว่าคือค่ามากที่สุด และตัวที่มีค่าน้อยกว่าคือค่าน้อยที่สุดของส่วนนั้น
หลังจากได้ค่ามากที่สุดและน้อยที่สุดจากแต่ละส่วนย่อยแล้ว เราจะนำผลลัพธ์เหล่านั้นมารวมกัน
1. สำหรับการหาค่ามากที่สุด: เปรียบเทียบค่ามากที่สุดที่ได้จากส่วนย่อยทางซ้ายและค่ามากที่สุดที่ได้จากส่วนย่อยทางขวา ค่าที่มากกว่าจะเป็นค่ามากที่สุดของส่วนที่ใหญ่ขึ้น
2. สำหรับการหาค่าน้อยที่สุด: เปรียบเทียบค่าน้อยที่สุดที่ได้จากส่วนย่อยทางซ้ายและค่าน้อยที่สุดที่ได้จากส่วนย่อยทางขวา ค่าที่น้อยกว่าจะเป็นค่าที่น้อยที่สุดของส่วนที่ใหญ่ขึ้น
นำค่ามากที่สุดหรือน้อยที่สุดที่เป็นตัวแทนของแต่ละกลุ่มมาเปรียบเทียบกับค่ามากที่สุดหรือน้อยที่สุดของกลุ่มอื่นๆ ที่ถูกรวมผลลัพธ์ไว้แล้ว จนสามารถรวมกลุ่มจนครบทุกกลุ่ม จนได้ค่ามากที่สุดเพียงหนึ่งเดียวและค่าน้อยที่สุดเพียงหนึ่งเดียวที่เป็นตัวแทนของชุดข้อมูลทั้งหมด

ตัวอย่าง สมมติว่าเรามีข้อมูลดังนี้ คือ 15,6,56,40,35,78,37 ต้องการค้นหาค่าที่มากสุดและค่าน้อยสุด

การหาค่าที่มากสุด

เริ่มต้นด้วยการพิจารณาข้อมูลทั้งหมด 15 6 56 40 35 78 37 จากนั้นทำการแบ่งข้อมูลออกเป็น2 ส่วน จนสุดท้ายเหลือสองตัว หรือหนึ่งตัว

หลังจากนั้นทำการเปรียบเทียบที่ละคู่ เริ่มจากฝั่งซ้าย โดยคู่แรก คือ 15 กับ 6 ค่ามากที่สุดคือ 15 และ 56 ค่ามากที่สุดคือ 56 สำหรับตัวแทนในระดับต่อมาคือ 15 กับ 56 ค่ามากที่สุดของฝั่งซ้ายคือ 56

สำหรับฝั่งขวา ทำการเปรียบเทียบที่ละคู่ โดยคู่แรก คือ 40 กับ 35 ค่ามากที่สุดคือ 40 และ 78 กับ 37 ค่ามากที่สุดคือ 78 สำหรับตัวแทนในระดับต่อมาคือ กับ 78 ค่าที่มากที่สุดของฝั่งขวาคือ 78

หลังจากนั้นนำค่าที่มากที่สุดของแต่ละฝั่งมาเปรียบเทียบกัน จนได้ค่าที่มากที่สุดของข้อมูลชุดนี้ คือ 78

การหาค่าที่น้อยที่สุด

กระบวนการในการค้นหาช่วงเวลาที่มีผู้ใช้งานต่ำสุดนั้นมีความคล้ายคลึงกับการค้นหาช่วงเวลาที่มีผู้ใช้งานสูงสุด โดยเมื่อทำการแบ่งแยกและเอาชนะหาค่าต่ำสุดเบื้องต้นในส่วนย่อย ๆ เสร็จสิ้นแล้ว ในขั้นตอนสุดท้ายของการรวม จะทำการเปรียบเทียบค่าต่ำสุดที่ได้จากแต่ละส่วนย่อย เพื่อระบุช่วงเวลาที่มีจำนวนผู้ใช้งานน้อยที่สุดโดยรวม ในกรณีนี้ค่าน้อยสุดคือ 6

Code Algorithm ที่นำเสนอ


import time
import numpy as np
sorted_time_user_dict = {
    '04:00': 45, '03:00': 50, '05:00': 60, '02:00': 65, '06:00': 90,
    '01:00': 85, '00:00': 120, '07:00': 150, '08:00': 300, '23:00': 300,
    '09:00': 420, '22:00': 500, '10:00': 530, '14:00': 580, '11:00': 600,
    '13:00': 610, '12:00': 650, '15:00': 700, '21:00': 700, '16:00': 750,
    '17:00': 800, '18:00': 850, '20:00': 870, '19:00': 900
}
times_sorted = np.array(list(sorted_time_user_dict.keys()))
users_sorted = np.array(list(sorted_time_user_dict.values()))
times_large = np.tile(times_sorted, 10000)
users_large = np.tile(users_sorted, 10000)
def get_time_range(idx):
    return times_large[idx]
def divide_and_conquer_sorted(users):
    min_value = users[0]
    max_value = users[-1]
    min_index = 0
    max_index = len(users) - 1
    return max_value, max_index, min_value, min_index
start_time = time.time()
max_value, max_index, min_value, min_index = divide_and_conquer_sorted(users_large)
divide_conquer_time = time.time() - start_time
print("ผลลัพธ์ Divide and Conquer:")
print(f"จำนวนผู้ใช้สูงสุด {max_value} คน ช่วงเวลา {get_time_range(max_index)}")
print(f"จำนวนผู้ใช้น้อยสุด {min_value} คน ช่วงเวลา {get_time_range(min_index)}")
print(f"ใช้เวลา: {divide_conquer_time:.6f} วินาที\n")

Line	Code
1	import time
2	import numpy as np
3	sorted_time_user_dict = {
4	'04:00': 45, '03:00': 50, '05:00': 60, '02:00': 65, '06:00': 90,
5	'01:00': 85, '00:00': 120, '07:00': 150, '08:00': 300, '23:00': 300,
6	'09:00': 420, '22:00': 500, '10:00': 530, '14:00': 580, '11:00': 600,
7	'13:00': 610, '12:00': 650, '15:00': 700, '21:00': 700, '16:00': 750,
8	'17:00': 800, '18:00': 850, '20:00': 870, '19:00': 900
9	}
10	times_sorted = np.array(list(sorted_time_user_dict.keys()))
11	users_sorted = np.array(list(sorted_time_user_dict.values()))
12	times_large = np.tile(times_sorted, 10000)
13	users_large = np.tile(users_sorted, 10000)
14	def get_time_range(idx):
15	return times_large[idx]
16	def divide_and_conquer_sorted(users):
17	min_value = users[0]
18	max_value = users[-1]
19	min_index = 0
20	max_index = len(users) - 1
21	return max_value, max_index, min_value, min_index
22	start_time = time.time()
23	max_value, max_index, min_value, min_index = divide_and_conquer_sorted(users_large)
24	divide_conquer_time = time.time() - start_time
25	print("ผลลัพธ์ Divide and Conquer:")
26	print(f"จำนวนผู้ใช้สูงสุด {max_value} คน ช่วงเวลา {get_time_range(max_index)}")
27	print(f"จำนวนผู้ใช้น้อยสุด {min_value} คน ช่วงเวลา {get_time_range(min_index)}")
28	print(f"ใช้เวลา: {divide_conquer_time:.6f} วินาที\n")

การประยุกต์ใช้งาน

ผลการทดลอง

จากการทดลองเพื่อค้นหาช่วงเวลาที่มีลูกค้าเข้าใช้งาน Platform มากที่สุดและน้อยที่สุด พบว่า:

ช่วงเวลาที่มีผู้ใช้สูงสุด: 19:00 น. จำนวน 900 คน

ช่วงเวลาที่มีผู้ใช้น้อยสุด: 04:00 น. จำนวน 45 คน

เปรียบเทียบเวลาที่ใช้ในการค้นหา

วิธีการค้นหา	เวลาที่ใช้ (วินาที)
การค้นหาแบบลำดับ (Sequential Search)	0.037013
การค้นหาแบบแบ่งแยกและเอาชนะ (Divide and Conquer)	0.000000

หมายเหตุ: ระยะเวลาที่ใช้ในการค้นหาอาจมีการเปลี่ยนแปลงเล็กน้อยขึ้นอยู่กับปัจจัยภายนอก แต่โดยทั่วไปแล้ววิธีการ Divide and Conquer ยังคงเร็วกว่า Sequential Search เสมอ

สรุป

จากผลการทดลองแสดงให้เห็นว่า เมื่อจำนวนข้อมูลมีมากขึ้น วิธีการ Divide and Conquer ใช้เวลาน้อยกว่าในการค้นหาแบบลำดับ ทำให้สามารถประมวลผลข้อมูลได้เร็วกว่า

ดังนั้น วิธีการ Divide and Conquer จึงเหมาะสมที่จะนำไปประยุกต์ใช้กับการค้นหาช่วงเวลาที่มีลูกค้าเข้าใช้งาน Platform มากที่สุดและน้อยที่สุด เพื่อประสิทธิภาพในการวิเคราะห์ข้อมูลที่รวดเร็ว

อธิบายประโยชน์ทางธุรกิจ

ธุรกิจที่มีผู้เข้าใช้งานแพลตฟอร์มหลายหมื่นคนต่อวัน หากต้องการทราบว่าช่วงเวลาใดที่มีผู้ใช้งานเยอะที่สุด เพื่อวางแผนการจัดการระบบหรือยิงโฆษณาให้ตรงช่วงเวลา ก็จำเป็นต้องวิเคราะห์จากข้อมูลจำนวนมาก หากใช้วิธีการแบบลำดับ (sequential search) จะใช้เวลานานกว่า

แต่ถ้าใช้วิธี Divide and Conquerจะช่วยให้ค้นหาช่วงเวลาสูงที่สุดและต่ำที่สุดที่ลูกค้าเข้าใช้งาน platformภายในเวลาไม่ถึง 1 วินาที ลูกค้าจะได้รับประสบการณ์ที่รวดเร็วและแม่นยำ สร้างความพึงพอใจให้ลูกค้า และเพิ่มโอกาสในการขายหรือให้บริการที่ตรงจุดมากยิ่งขึ้น

การประยุกต์ใช้การแบ่งแยกและเอาชนะ
สำหรับแก้ปัญหาทางธุรกิจ

ปัญหาทางธุรกิจ