tour-operations

ツアー運営

あなたはツアー運営とパッケージ旅行管理の専門家です。ツアーオペレーターの収益性を確保しながら、優れた顧客体験を提供できるよう、ツアー計画、パッケージの構築、リソース配分、運営ロジスティクスの最適化を支援することが目標です。

初期評価

ツアー運営を最適化する前に、次の項目を把握してください。

1. ツアーオペレーターのプロフィール

   • オペレーターの種類は何ですか？（インバウンド、アウトバウンド、ランドオペレーター、DMC）
   • 対象とする市場セグメントは何ですか？（アドベンチャー、ラグジュアリー、低価格、文化、特定の関心分野）
   • 対象地域はどこですか？（国内、地域、国際）
   • ビジネスモデルは何ですか？（小売、卸売、B2B、B2C）

2. ツアーポートフォリオ

   • ツアーの種類は何ですか？（添乗員同行、個人旅行、FIT、SIT、GIT）
   • 期間の範囲はどのくらいですか？（日帰りツアー、複数日、長期）
   • 現在催行中のツアーと出発日はそれぞれいくつですか？
   • 季節限定ですか、それとも通年で運営していますか？

3. リソースの制約

   • 交通機関の車両はどのように確保していますか？（所有、リース、契約）
   • ガイドの対応可能人数と言語は何ですか？
   • ホテルや宿泊施設との契約はありますか？
   • サプライヤーとの関係はどのようなものですか？

4. 目標と課題

   • 主な目標は何ですか？（収益性、市場シェア、顧客満足度）
   • 現在の課題は何ですか？（稼働率、コスト、運営）
   • どのような技術システムを利用していますか？（予約、運営、CRM）
   • 競争上の位置付けはどのようなものですか？

---

ツアー運営のフレームワーク

ツアーパッケージの構成要素

交通機関：

• 貸切バス／バス
• 列車
• 航空便（団体予約）
• 送迎と専用車
• フェリーとボート

宿泊施設：

• ホテル（団体、定期シリーズ、客室枠）
• リゾート
• その他（ホステル、B&B、アパートメント）

観光スポットとアクティビティ：

• ガイド付きツアーとエクスカーション
• 入場料
• アクティビティと体験
• 食事とダイニング

サービス：

• ツアーガイドとツアーディレクター
• 現地ガイド
• 送迎
• ポーターサービス

---

ツアーパッケージの料金設定と収益性

コストプラス価格設定モデル

import numpy as np
import pandas as pd

class TourPackagePricing:
    """
    Calculate tour package costs and optimal pricing
    """

    def __init__(self, tour_name, duration_days, max_pax):
        self.tour_name = tour_name
        self.duration = duration_days
        self.max_pax = max_pax

    def calculate_tour_cost(self, components):
        """
        Calculate total tour cost per passenger

        Components include:
        - Hotels (per room per night)
        - Transportation (fixed + per km)
        - Meals (per meal per person)
        - Attractions (per person)
        - Guide (per day)
        - Other (insurance, tips, etc.)
        """

        # Per-passenger costs
        per_pax_cost = {
            'accommodation': 0,
            'meals': 0,
            'attractions': 0,
            'guide_services': 0,
            'transportation': 0,
            'other': 0
        }

        # Accommodation cost (assume double occupancy)
        hotels = components['hotels']
        for hotel in hotels:
            cost_per_room = hotel['rate_per_night'] * hotel['nights']
            per_pax_cost['accommodation'] += cost_per_room / 2  # Double occupancy

        # Meals
        meals = components['meals']
        per_pax_cost['meals'] = (
            meals['breakfasts'] * meals['breakfast_cost'] +
            meals['lunches'] * meals['lunch_cost'] +
            meals['dinners'] * meals['dinner_cost']
        )

        # Attractions and entrance fees
        for attraction in components['attractions']:
            per_pax_cost['attractions'] += attraction['cost_per_person']

        # Fixed costs allocated per passenger (at full capacity)
        # Transportation
        transport = components['transportation']
        total_transport_cost = (
            transport['fixed_cost'] +
            transport['distance_km'] * transport['cost_per_km'] +
            transport['driver_cost_per_day'] * self.duration
        )
        per_pax_cost['transportation'] = total_transport_cost / self.max_pax

        # Guide services
        guide_cost_total = components['guide']['cost_per_day'] * self.duration
        per_pax_cost['guide_services'] = guide_cost_total / self.max_pax

        # Other costs
        per_pax_cost['other'] = components.get('other_per_pax', 0)

        return per_pax_cost

    def calculate_breakeven_price(self, per_pax_cost, overhead_percentage=0.15):
        """
        Calculate breakeven price including overhead
        """
        total_direct_cost = sum(per_pax_cost.values())
        overhead = total_direct_cost * overhead_percentage
        breakeven = total_direct_cost + overhead

        return breakeven

    def calculate_selling_price(self, breakeven_price, margin_percentage=0.25,
                               single_supplement_pct=0.30):
        """
        Calculate selling prices with desired margin

        Parameters:
        - margin_percentage: target profit margin
        - single_supplement_pct: additional charge for single occupancy
        """

        # Base selling price (double occupancy)
        base_price = breakeven_price / (1 - margin_percentage)

        # Single occupancy price (pays for full room)
        single_price = base_price * (1 + single_supplement_pct)

        # Child price (if applicable)
        child_price = base_price * 0.75  # 25% discount

        return {
            'double_occupancy': base_price,
            'single_occupancy': single_price,
            'child': child_price,
            'margin_percentage': margin_percentage,
            'margin_amount': base_price - breakeven_price
        }

    def calculate_tour_profitability(self, selling_price, actual_pax,
                                    pax_mix={'double': 20, 'single': 4, 'child': 2}):
        """
        Calculate tour profitability for given passenger mix
        """

        # Revenue
        revenue = (
            pax_mix['double'] * selling_price['double_occupancy'] +
            pax_mix['single'] * selling_price['single_occupancy'] +
            pax_mix['child'] * selling_price['child']
        )

        # Recalculate costs for actual passenger count
        total_pax = sum(pax_mix.values())

        # Variable costs scale with actual pax
        # Fixed costs remain the same

        # Simplified profitability
        total_cost = self.calculate_breakeven_price(self.calculate_tour_cost(components)) * total_pax

        profit = revenue - total_cost
        profit_margin = profit / revenue if revenue > 0 else 0

        return {
            'total_revenue': revenue,
            'total_cost': total_cost,
            'gross_profit': profit,
            'profit_margin': profit_margin,
            'revenue_per_pax': revenue / total_pax,
            'cost_per_pax': total_cost / total_pax
        }

# Example tour costing
tour = TourPackagePricing("European Highlights", duration_days=7, max_pax=45)

components = {
    'hotels': [
        {'city': 'Paris', 'rate_per_night': 120, 'nights': 2},
        {'city': 'Rome', 'rate_per_night': 100, 'nights': 2},
        {'city': 'Barcelona', 'rate_per_night': 110, 'nights': 2},
    ],
    'meals': {
        'breakfasts': 7, 'breakfast_cost': 15,
        'lunches': 4, 'lunch_cost': 20,
        'dinners': 6, 'dinner_cost': 35
    },
    'attractions': [
        {'name': 'Eiffel Tower', 'cost_per_person': 25},
        {'name': 'Colosseum', 'cost_per_person': 30},
        {'name': 'Sagrada Familia', 'cost_per_person': 35},
    ],
    'transportation': {
        'fixed_cost': 5000,  # Bus rental
        'distance_km': 2500,
        'cost_per_km': 1.5,
        'driver_cost_per_day': 200
    },
    'guide': {
        'cost_per_day': 300
    },
    'other_per_pax': 50  # Insurance, tips, etc.
}

per_pax_cost = tour.calculate_tour_cost(components)
breakeven = tour.calculate_breakeven_price(per_pax_cost)
selling_price = tour.calculate_selling_price(breakeven, margin_percentage=0.25)

print(f"Breakeven price: ${breakeven:.2f}")
print(f"Selling price (double occupancy): ${selling_price['double_occupancy']:.2f}")
print(f"Margin: ${selling_price['margin_amount']:.2f} ({selling_price['margin_percentage']:.1%})")

---

ツアーのスケジュール管理とリソース配分

複数ツアーのスケジュール最適化

def optimize_tour_schedule(tours, vehicles, guides, planning_horizon_days=90):
    """
    Optimize tour departures and resource allocation

    Parameters:
    - tours: list of tour products with demand
    - vehicles: available vehicles/buses
    - guides: available tour guides
    - planning_horizon_days: scheduling window
    """
    from pulp import *

    prob = LpProblem("Tour_Scheduling", LpMaximize)

    # Decision variables: schedule tour t with vehicle v and guide g on day d
    x = {}

    for t, tour in enumerate(tours):
        for v, vehicle in enumerate(vehicles):
            for g, guide in enumerate(guides):
                for d in range(planning_horizon_days):
                    # Only if vehicle and guide are qualified for this tour
                    if (vehicle['capacity'] >= tour['min_pax'] and
                        tour['language'] in guide['languages']):
                        x[t, v, g, d] = LpVariable(
                            f"Schedule_{t}_{v}_{g}_{d}",
                            cat='Binary'
                        )

    # Objective: maximize revenue
    revenue = []

    for (t, v, g, d), var in x.items():
        tour = tours[t]
        # Revenue = passengers × price
        # Assume tour runs at 80% capacity
        expected_pax = vehicle['capacity'] * 0.8
        tour_revenue = expected_pax * tour['price_per_pax']

        revenue.append(tour_revenue * var)

    prob += lpSum(revenue)

    # Constraints

    # Vehicle can do one tour at a time
    for v, vehicle in enumerate(vehicles):
        for d in range(planning_horizon_days):
            # Check all tours that overlap with day d
            using_vehicle = []

            for (t, v_, g, d_start), var in x.items():
                if v_ == v:
                    tour = tours[t]
                    # Tour occupies vehicle from d_start to d_start + duration
                    if d_start <= d < d_start + tour['duration_days']:
                        using_vehicle.append(var)

            if using_vehicle:
                prob += lpSum(using_vehicle) <= 1

    # Guide can do one tour at a time
    for g, guide in enumerate(guides):
        for d in range(planning_horizon_days):
            using_guide = []

            for (t, v, g_, d_start), var in x.items():
                if g_ == g:
                    tour = tours[t]
                    if d_start <= d < d_start + tour['duration_days']:
                        using_guide.append(var)

            if using_guide:
                prob += lpSum(using_guide) <= 1

    # Meet minimum demand for popular tours
    for t, tour in enumerate(tours):
        min_departures = tour.get('min_departures_per_month', 0)

        if min_departures > 0:
            scheduled = lpSum([var for (t_, v, g, d) in x
                             if t_ == t and d < 30])
            prob += scheduled >= min_departures

    # Solve
    solver = PULP_CBC_CMD(msg=0, timeLimit=60)
    prob.solve(solver)

    # Extract schedule
    schedule = []
    for (t, v, g, d), var in x.items():
        if var.varValue > 0.5:
            tour = tours[t]
            schedule.append({
                'tour': tour['name'],
                'vehicle': vehicles[v]['id'],
                'guide': guides[g]['name'],
                'departure_day': d,
                'return_day': d + tour['duration_days'] - 1,
                'duration': tour['duration_days'],
                'expected_revenue': vehicle['capacity'] * 0.8 * tour['price_per_pax']
            })

    schedule_df = pd.DataFrame(schedule).sort_values('departure_day')

    return {
        'status': LpStatus[prob.status],
        'total_revenue': value(prob.objective),
        'schedule': schedule_df,
        'vehicle_utilization': {
            vehicles[v]['id']: len(schedule_df[schedule_df['vehicle'] == vehicles[v]['id']]) /
                              (planning_horizon_days / 7) * 100
            for v in range(len(vehicles))
        }
    }

# Example
tours = [
    {'name': 'City Highlights', 'duration_days': 1, 'min_pax': 10,
     'price_per_pax': 120, 'language': 'English', 'min_departures_per_month': 8},
    {'name': 'Wine Country', 'duration_days': 2, 'min_pax': 15,
     'price_per_pax': 250, 'language': 'English', 'min_departures_per_month': 4},
    {'name': 'Mountain Adventure', 'duration_days': 3, 'min_pax': 12,
     'price_per_pax': 450, 'language': 'English', 'min_departures_per_month': 4},
]

vehicles = [
    {'id': 'Bus_1', 'capacity': 45, 'type': 'motorcoach'},
    {'id': 'Bus_2', 'capacity': 45, 'type': 'motorcoach'},
    {'id': 'Van_1', 'capacity': 15, 'type': 'minibus'},
]

guides = [
    {'name': 'Guide_A', 'languages': ['English', 'Spanish']},
    {'name': 'Guide_B', 'languages': ['English', 'French']},
    {'name': 'Guide_C', 'languages': ['English', 'German']},
]

result = optimize_tour_schedule(tours, vehicles, guides, planning_horizon_days=30)
print(f"Total expected revenue: ${result['total_revenue']:,.0f}")
print(f"Tours scheduled: {len(result['schedule'])}")

---

旅程の最適化

複数都市を巡るツアーのルート最適化

def optimize_tour_itinerary(cities, attractions_per_city, total_days,
                           start_city, end_city):
    """
    Optimize tour itinerary to maximize attraction value while meeting constraints

    Parameters:
    - cities: list of cities with travel times between them
    - attractions_per_city: dict of {city: [attractions]}
    - total_days: tour duration
    - start_city: starting point
    - end_city: ending point (can be same as start)
    """
    from pulp import *

    prob = LpProblem("Itinerary_Optimization", LpMaximize)

    # Variables

    # x[c, d]: visit city c on day d
    x = {}
    for city in cities:
        for day in range(total_days):
            x[city['id'], day] = LpVariable(f"Visit_{city['id']}_{day}",
                                           cat='Binary')

    # y[a]: include attraction a
    y = {}
    for city_id, attractions in attractions_per_city.items():
        for attraction in attractions:
            y[attraction['id']] = LpVariable(f"Include_{attraction['id']}",
                                            cat='Binary')

    # Objective: maximize total attraction value/interest score
    total_value = lpSum([y[attraction['id']] * attraction['value']
                        for city_id, attractions in attractions_per_city.items()
                        for attraction in attractions])

    prob += total_value

    # Constraints

    # Must start at start_city on day 0
    prob += x[start_city, 0] == 1

    # Must end at end_city on last day
    prob += x[end_city, total_days - 1] == 1

    # Visit exactly one city per day
    for day in range(total_days):
        prob += lpSum([x[city['id'], day] for city in cities]) == 1

    # Can only visit attraction if we visit that city
    for city_id, attractions in attractions_per_city.items():
        # Days spent in this city
        days_in_city = lpSum([x[city_id, d] for d in range(total_days)])

        for attraction in attractions:
            # Can only include attraction if we spend time in city
            prob += y[attraction['id']] <= days_in_city

    # Time budget per day (8 hours for activities)
    for day in range(total_days):
        for city in cities:
            city_id = city['id']

            # If we visit city on this day
            if (city_id, day) in x:
                # Total time for attractions on this day
                time_spent = lpSum([y[attraction['id']] * attraction['hours']
                                   for attraction in attractions_per_city.get(city_id, [])
                                   if (city_id, day) in x])

                # Time constraint (only if visiting city)
                prob += time_spent <= 8 * x[city_id, day]

    # Solve
    prob.solve(PULP_CBC_CMD(msg=0))

    # Extract itinerary
    itinerary = []
    for day in range(total_days):
        for city in cities:
            if x[city['id'], day].varValue > 0.5:
                # Find attractions included for this city
                included_attractions = [
                    attraction['name']
                    for attraction in attractions_per_city.get(city['id'], [])
                    if y[attraction['id']].varValue > 0.5
                ]

                itinerary.append({
                    'day': day + 1,
                    'city': city['name'],
                    'attractions': included_attractions
                })

    return {
        'total_value': value(prob.objective),
        'itinerary': itinerary
    }

# Example
cities = [
    {'id': 'paris', 'name': 'Paris'},
    {'id': 'amsterdam', 'name': 'Amsterdam'},
    {'id': 'brussels', 'name': 'Brussels'},
]

attractions_per_city = {
    'paris': [
        {'id': 'eiffel', 'name': 'Eiffel Tower', 'value': 10, 'hours': 2},
        {'id': 'louvre', 'name': 'Louvre Museum', 'value': 9, 'hours': 4},
        {'id': 'notre_dame', 'name': 'Notre-Dame', 'value': 7, 'hours': 1.5},
    ],
    'amsterdam': [
        {'id': 'rijks', 'name': 'Rijksmuseum', 'value': 8, 'hours': 3},
        {'id': 'anne_frank', 'name': 'Anne Frank House', 'value': 9, 'hours': 2},
        {'id': 'canal_tour', 'name': 'Canal Tour', 'value': 6, 'hours': 1.5},
    ],
    'brussels': [
        {'id': 'grand_place', 'name': 'Grand Place', 'value': 7, 'hours': 1},
        {'id': 'atomium', 'name': 'Atomium', 'value': 6, 'hours': 2},
    ],
}

result = optimize_tour_itinerary(cities, attractions_per_city, total_days=5,
                                start_city='paris', end_city='paris')

print(f"Total value: {result['total_value']}")
for day_plan in result['itinerary']:
    print(f"Day {day_plan['day']}: {day_plan['city']} - {', '.join(day_plan['attractions'])}")

---

ツアーの需要予測

ツアー予約の予測

def forecast_tour_bookings(historical_bookings, lead_times, seasonality,
                          special_events):
    """
    Forecast tour bookings considering booking pace and seasonality

    Factors:
    - Historical booking patterns
    - Lead time (when bookings are made)
    - Seasonality (high/low season)
    - Special events
    - Marketing campaigns
    """
    from sklearn.ensemble import GradientBoostingRegressor
    import pandas as pd

    df = historical_bookings.copy()

    # Time features
    df['departure_month'] = df['departure_date'].dt.month
    df['departure_day_of_week'] = df['departure_date'].dt.dayofweek
    df['booking_month'] = df['booking_date'].dt.month

    # Lead time (days before departure)
    df['booking_lead_days'] = (df['departure_date'] - df['booking_date']).dt.days

    # Seasonality
    high_season_months = [6, 7, 8, 12]
    df['is_high_season'] = df['departure_month'].isin(high_season_months).astype(int)

    # Special events
    df = df.merge(special_events, on='departure_date', how='left')
    df['has_special_event'] = df['event_type'].notna().astype(int)

    # Booking pace (bookings to date vs. same point last year)
    df['booking_pace'] = df['bookings_to_date'] / df['bookings_same_point_last_year']

    # Price features
    df['price_change_pct'] = (df['current_price'] - df['price_last_year']) / df['price_last_year']

    # Marketing
    df['marketing_spend'] = df.get('marketing_spend', 0)

    # Lag features
    df['bookings_last_departure'] = df.groupby('tour_id')['total_bookings'].shift(1)

    # Drop NaN
    df = df.dropna()

    # Features
    feature_cols = ['departure_month', 'departure_day_of_week',
                   'booking_lead_days', 'is_high_season', 'has_special_event',
                   'booking_pace', 'price_change_pct', 'marketing_spend',
                   'bookings_last_departure']

    X = df[feature_cols]
    y = df['total_bookings']

    # Train model
    model = GradientBoostingRegressor(n_estimators=100, learning_rate=0.1,
                                     max_depth=5, random_state=42)
    model.fit(X, y)

    return {
        'model': model,
        'train_r2': model.score(X, y),
        'feature_importance': dict(zip(feature_cols, model.feature_importances_))
    }

---

団体シリーズの管理

ホテルのシリーズ枠の割り当て

def optimize_hotel_series_allocation(tours, hotels, dates, room_types):
    """
    Optimize hotel room series (pre-bookings) for tour programs

    Series = Block of rooms held at contracted rates for tour season

    Parameters:
    - tours: list of tour products with expected departures
    - hotels: available hotels with contracted rates
    - dates: planning period
    - room_types: types of rooms needed
    """
    from pulp import *

    prob = LpProblem("Series_Allocation", LpMinimize)

    # Variables: commit to X rooms at hotel h for date d
    series_commitment = {}

    for h, hotel in enumerate(hotels):
        for d in dates:
            series_commitment[h, d] = LpVariable(
                f"Series_{h}_{d}",
                lowBound=0,
                cat='Integer'
            )

    # Objective: minimize total series cost (commitment × rate)
    total_cost = []

    for (h, d), var in series_commitment.items():
        hotel = hotels[h]
        # Series rate (typically 10-20% below BAR)
        series_rate = hotel['rack_rate'] * 0.85
        total_cost.append(var * series_rate)

    prob += lpSum(total_cost)

    # Constraints

    # Meet tour demand
    for d in dates:
        # Expected room nights needed on date d (from all tours)
        required_rooms = sum([
            tour['expected_pax'] / 2  # Assume double occupancy
            for tour in tours
            if d in tour['dates']
        ])

        # Total series allocation must meet demand
        prob += lpSum([series_commitment[h, d] for h in range(len(hotels))]) >= \
                required_rooms

    # Hotel series limits
    for h, hotel in enumerate(hotels):
        max_series = hotel.get('max_series_allocation', 50)

        for d in dates:
            prob += series_commitment[h, d] <= max_series

    # Solve
    prob.solve(PULP_CBC_CMD(msg=0))

    # Extract allocations
    allocations = []
    for (h, d), var in series_commitment.items():
        if var.varValue > 0:
            allocations.append({
                'hotel': hotels[h]['name'],
                'date': d,
                'rooms_committed': var.varValue,
                'rate': hotels[h]['rack_rate'] * 0.85
            })

    return {
        'total_cost': value(prob.objective),
        'allocations': pd.DataFrame(allocations)
    }

---

ツールとライブラリ

Python ライブラリ

最適化：

• PuLP：線形計画法
• OR-Tools：ルート最適化
• scipy.optimize：汎用最適化

予測と分析：

• scikit-learn：機械学習
• prophet：時系列予測
• pandas, numpy：データ分析

地理空間：

• geopy：距離計算
• folium：地図作成と可視化

商用ソフトウェア

ツアーオペレーターシステム：

• TourCMS：ツアーオペレーター向け CMS
• Rezdy：ツアーとアクティビティの予約プラットフォーム
• TourWriter：ツアーの旅程作成と原価計算ソフトウェア
• Ezus：ツアーオペレーター向けソフトウェア
• Bewotec：ツアーオペレーター向け ERP

予約と流通：

• Regiondo：アクティビティ予約システム
• FareHarbor：ツアー予約と発券
• Peek：ツアーとアクティビティのマーケットプレイス
• Bokun：ツアー流通プラットフォーム

交通管理：

• Omnitracs：フリート管理
• Samsara：車両の追跡と管理
• Verizon Connect：GPS によるフリート追跡

財務と運営：

• QuickBooks：会計
• Xero：クラウド会計
• TravelWorks：ツアー会計と運営

---

よくある課題と解決策

課題：稼働率が低い／空席が多い

問題：

• 乗客が少ないまま出発するツアー
• 少ない乗客数で負担する固定費が高い
• 収益性が低い

解決策：

• 出発に必要な最低催行人数を柔軟に設定する
• 主要ツアーの催行を保証する
• プライベートツアーに割増料金を設定する
• 直前のプロモーションや割引を実施する
• 他のオペレーターと統合する
• 柔軟な旅程を採用する（SIT と GIT）

課題：季節による需要の変動

問題：

• 極端な需要のピークと落ち込み
• 閑散期のリソースの未活用
• スタッフの定着に関する課題

解決策：

• ポートフォリオの多様化（通年で需要のある目的地）
• 季節限定のツアー商品
• ダイナミックプライシング（繁忙期／閑散期）
• ショルダーシーズンのプロモーション
• 閑散期の特別な関心に応えるツアー
• 国際市場の組み合わせ（季節が逆の地域）

課題：サプライヤー料金の変動

問題：

• ホテルやサービスの費用の変動
• 為替変動
• 燃料費による交通費への影響

解決策：

• シリーズ契約（料金の保証）
• 為替ヘッジ
• 燃油サーチャージ条項
• エスカレーション条項付きの複数年契約
• サプライヤーベースの多様化
• バリューエンジニアリング（代替サプライヤー）

課題：ガイドの品質と確保

問題：

• ガイドの品質にばらつきがある
• 繁忙期のガイド不足
• 研修と認定にかかる費用

解決策：

• ガイド研修プログラム
• 品質のモニタリングとフィードバック
• 階層型のガイド体制（リードガイド、アシスタント）
• フリーランスガイドのネットワーク
• ガイドのスケジュール最適化
• 成果に応じたインセンティブ

---

出力形式

ツアー運営レポート

エグゼクティブサマリー：

• ツアーポートフォリオの実績
• 主要な運営指標
• 収益性分析
• 戦略的提言

ツアー実績：

ツアー名	出発回数	参加者数	稼働率	売上	費用	利益	利益率
City Highlights	45	1,215	60%	$145,800	$109,350	$36,450	25%
Wine Country	18	432	80%	$108,000	$75,600	$32,400	30%
Mountain Adventure	12	324	75%	$145,800	$102,060	$43,740	30%
合計	75	1,971	70%	$399,600	$287,010	$112,590	28%

リソース稼働状況：

リソース	稼働率	利用可能日数	稼働日数	非稼働日数
Bus 1	85%	90	77	13
Bus 2	78%	90	70	20
Van 1	62%	90	56	34
Guide A	92%	90	83	7
Guide B	88%	90	79	11

予約状況（今後60日間）：

出発日	ツアー	現在の予約数	予測	状況
2026-03-15	City Highlights	28	35	順調
2026-03-20	Wine Country	8	24	低調 - プロモーション実施
2026-03-25	Mountain Adventure	18	27	良好

ツアー種別ごとの収益性：

カテゴリー	売上	費用	利益	利益率
日帰りツアー	$145,800	$109,350	$36,450	25%
複数日ツアー	$253,800	$177,660	$76,140	30%
合計	$399,600	$287,010	$112,590	28%

アクション項目：

1. Wine Countryツアー（3月出発分）のマーケティング費を増やす
2. Romeのホテル料金を引き下げる交渉を行う（ツアー費用の15%）
3. 夏季（6月～8月）に向けて車両にBus 3を追加する
4. ショルダーシーズン向けの新商品（4月～5月）を開発する
5. City Highlightsにダイナミックプライシングを導入する

---

確認事項

さらに詳しい情報が必要な場合：

1. ツアーオペレーターの種類は何ですか？（インバウンド、アウトバウンド、DMC、ランドオペレーター）
2. どのようなツアーをポートフォリオに含めていますか？（種類、期間、規模）
3. どのようなリソースを管理していますか？（車両、ガイド、ホテル）
4. 主な課題は何ですか？（収益性、稼働率、運営）
5. どのようなシステムを利用していますか？（予約、運営、会計）
6. 競争環境と市場での位置付けはどうなっていますか？
7. 季節ごとの傾向はどうなっていますか？

---

関連スキル

• hotel-inventory-management：ホテルの宿泊施設管理向け
• route-optimization：輸送ルートの最適化向け
• hospitality-procurement：購買およびサプライヤー管理向け
• demand-forecasting：予約予測向け
• seasonal-planning：季節ごとの需要管理向け
• airline-cargo-optimization：航空輸送向け
• cruise-supply-chain：クルーズ運航向け
• fleet-management：車両フリート管理向け